From 434f3122dd932af461554636136cbd38666e368e Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 17:58:51 -0600 Subject: [PATCH 001/171] feat(bolt): type generated verifier plans --- crates/bolt/GOAL.md | 209 +++++- crates/bolt/src/protocols/jolt/artifacts.rs | 417 +++++------- .../protocols/jolt/emit/rust/commitment.rs | 11 +- .../bolt/src/protocols/jolt/emit/rust/mod.rs | 1 + .../protocols/jolt/emit/rust/plan_tokens.rs | 212 +++++++ .../src/protocols/jolt/emit/rust/stage1.rs | 111 ++-- .../src/protocols/jolt/emit/rust/stage2.rs | 325 ++++------ .../src/protocols/jolt/emit/rust/stage3.rs | 220 ++++--- .../src/protocols/jolt/emit/rust/stage4.rs | 261 ++++---- .../src/protocols/jolt/emit/rust/stage5.rs | 263 ++++---- .../src/protocols/jolt/emit/rust/stage6.rs | 275 ++++---- .../src/protocols/jolt/emit/rust/stage7.rs | 281 +++++---- .../src/protocols/jolt/emit/rust/stage8.rs | 462 ++++++++++++-- .../jolt/verifier_common.rs.template | 209 ++++-- crates/bolt/tests/commitment_ir.rs | 24 +- crates/jolt-prover/src/prover.rs | 210 +++--- crates/jolt-prover/src/stages/commitment.rs | 45 +- crates/jolt-prover/src/stages/stage1_outer.rs | 22 +- crates/jolt-prover/src/stages/stage2.rs | 24 +- crates/jolt-prover/src/stages/stage3.rs | 14 +- crates/jolt-prover/src/stages/stage4.rs | 16 +- crates/jolt-prover/src/stages/stage5.rs | 16 +- crates/jolt-prover/src/stages/stage6.rs | 16 +- crates/jolt-prover/src/stages/stage7.rs | 14 +- crates/jolt-prover/src/stages/stage8.rs | 483 ++++++++++---- crates/jolt-verifier/src/stages/commitment.rs | 45 +- crates/jolt-verifier/src/stages/common.rs | 209 ++++-- .../jolt-verifier/src/stages/stage1_outer.rs | 127 ++-- crates/jolt-verifier/src/stages/stage2.rs | 344 ++++------ crates/jolt-verifier/src/stages/stage3.rs | 185 +++--- crates/jolt-verifier/src/stages/stage4.rs | 136 ++-- crates/jolt-verifier/src/stages/stage5.rs | 232 ++++--- crates/jolt-verifier/src/stages/stage6.rs | 597 +++++++++--------- crates/jolt-verifier/src/stages/stage7.rs | 417 ++++++------ crates/jolt-verifier/src/stages/stage8.rs | 420 ++++++++---- crates/jolt-verifier/src/verifier.rs | 205 ++---- 36 files changed, 3992 insertions(+), 3066 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index 4f0aa601ff..390ccfbbc3 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -75,45 +75,159 @@ generic Bolt compiler infrastructure: still genuinely protocol-specific and which are ready to lift into generic typed-plan emission. -## Immediate Goal-Mode Slice +## Current State -First objective for another agent: +The initial quarantine slice is complete: ```text -Quarantine Jolt-specific artifact APIs out of generic Rust artifact assembly -while preserving generated output and all current gates. +generic artifact assembly no longer owns Jolt artifact APIs +root bolt exports keep Jolt helpers under bolt::protocols::jolt +generic compiler source is guarded against accidental Jolt protocol strings +checked-in generated verifier is under the current LOC target +shared verifier plan/runtime scaffolding exists in stages/common.rs ``` -Required steps: - -1. Move `JoltProtocolStage`, `jolt_artifact_config`, `jolt_rust_artifact`, - `assemble_jolt_*`, `write_jolt_generated_crates`, and - `validate_jolt_rust_artifact_imports` out of generic - `crates/bolt/src/emit/rust/artifacts.rs` into a Jolt-owned module such as - `crates/bolt/src/protocols/jolt/artifacts.rs`. -2. Keep `ProtocolArtifactConfig`, `ProtocolStage`, `ProtocolRustArtifact`, - `GeneratedCrate`, `assemble_generated_crates`, `write_generated_crates`, and - `validate_rust_artifact_imports` in the generic artifact layer. -3. Stop re-exporting Jolt APIs from `crates/bolt/src/lib.rs`; update callers in - Bolt tests, `jolt-equivalence`, and perf harnesses to import from - `bolt::protocols::jolt`. -4. Add the first genericity hygiene test that rejects new Jolt protocol strings - in generic compiler modules, using a small documented allowlist only for - migration leftovers. -5. Run focused generation/import gates and confirm checked-in generated role - crates are unchanged unless an intentional artifact-structure change is - documented. - -Acceptance criteria: +The remaining work is no longer a stage bring-up task or a pure LOC cleanup. +This goal is now owned as a verifier-quality cutover: make the generated +verifier a Rust artifact that a reviewer can audit directly, without needing to +understand Bolt lowering internals. -```text -generic artifact assembly has no Jolt stage enum or Jolt artifact config -root bolt exports are generic-only -Jolt artifact helpers are namespaced under protocols::jolt -generated jolt-prover/jolt-verifier are byte-for-byte unchanged, or changes are intentional -genericity hygiene gate exists -existing generated-artifact and verifier-boundary gates pass -``` +## Completion Plan + +Work proceeds in reviewable slices. Each slice must reduce a concrete readability +or soundness risk, regenerate checked-in artifacts, and preserve the semantic +oracles. + +1. **Typed plan vocabulary** + + Replace execution-relevant strings with typed Rust plan data: + + ```text + StageId + ProofSlot + ProgramStepKind + TranscriptEventKind + RelationKind + FieldExprKind + OracleId + DomainId + ClaimKind + PointSource + EvalSource + OpeningEqualityMode + ``` + + Diagnostic names may remain as `symbol` fields, but verifier execution must + not branch on loose strings when a closed enum or structured ID can express + the same fact. + +2. **Generic stage runtime** + + Collapse stage-local verifier loops into one reviewed runtime path: + + ```text + verify transcript events + evaluate field expression plans + verify sumcheck drivers + collect named evals and output claims + construct opening claims + check opening equalities + convert proof records into runtime inputs + ``` + + Stage files should keep only stage-specific plan constants, typed relation + adapters when truly required, and thin `verify_stageN` wrappers. + +3. **Readable generated plan layout** + + Reformat emitted Rust so a human can scan it by protocol concept: + + ```text + params + transcript events + opening inputs + field expressions + sumcheck drivers + evals + opening claims + opening batches + stage program + ``` + + Avoid generated one-line functions, `#[rustfmt::skip]` blocks for ordinary + data, pipe-delimited operand strings, and stage-local macro tricks unless + they make the artifact materially easier to read. + +4. **Compact expression encoding** + + Replace verbose string formulas and operand encodings with typed compact + expression rows: + + ```text + FieldExprKind::Add { lhs, rhs } + FieldExprKind::Mul { lhs, rhs } + FieldExprKind::Pow { base, exponent } + FieldExprKind::LagrangeBasisEval { domain, index, point } + ``` + + Repeated operands and symbols should be pooled or indexed when doing so makes + the generated Rust clearer, not merely shorter. + +5. **Typed relation dispatch** + + Replace relation-name matching with typed `RelationKind` dispatch and + relation-specific plan payloads. Any remaining string dispatch must be + explicitly allowlisted, documented as temporary, and protected by tests that + fail when the allowlist grows. + +6. **Stage 8 boundary cleanup** + + Keep Dory/evaluation verification reviewed and explicit, but give Stage 8 a + typed input contract from earlier stages: + + ```text + committed opening IDs + virtual opening IDs + ordered opening batches + evaluation point sources + PCS proof slots + transcript labels + ``` + + Stage 8 does not have to become fully generic before this goal completes, but + it must not rely on name-then-position fallback or hidden generated ordering. + +7. **Hardening suite** + + Add or preserve negative oracles while the Rust shape changes. The generated + verifier must reject malformed plans/proofs with typed errors, not panic or + silently default missing values. + +8. **Independent readability review** + + Treat readability as a first-class gate. Before declaring this goal complete, + run a blind review where reviewers see only: + + ```text + current handwritten/verifier-style Rust surface + generated jolt-verifier Rust surface + brief protocol-stage context + no Bolt lowering or emitter implementation details + ``` + + A small council of reviewers, human or model, should be able to answer: + + ```text + What does each stage verify? + Where are transcript challenges absorbed or squeezed? + Which openings are checked, and at what points? + Where does sumcheck verification happen? + What code is trusted runtime logic versus declarative generated data? + How would a malformed proof be rejected? + ``` + + The generated verifier passes this gate only if the answers are findable from + the emitted Rust with minimal compiler context. ## Non-Negotiables @@ -304,8 +418,16 @@ no duplicate stage-local field-expression interpreter no duplicate stage-local opening equality interpreter no giant per-expression operand constants after compaction stage files are mostly declarative plan data +generated functions are rustfmt-formatted and scan-friendly +execution-relevant plan fields are typed unless explicitly allowlisted +relation dispatch string sites trend to zero +field-expression formula strings trend to zero ``` +LOC gates are guardrails, not the quality definition. A shorter verifier that +hides semantics in opaque runtime code or compiler-only conventions fails this +goal. + Security and boundary gates: ```text @@ -318,6 +440,9 @@ no kernel attrs in verifier CPU IR all transcript-producing ops thread transcript state all opening batches preserve explicit ordered claims all relation dispatch is typed or allowlisted +missing proof data returns typed verifier errors +duplicate or inconsistent opening claims reject explicitly +name-then-position eval fallback is absent from verifier execution ``` Semantic gates: @@ -342,6 +467,18 @@ core and Bolt reject equivalent tampered proofs generated prover/verifier crates stay in sync with artifact rail ``` +Subjective readability gate: + +```text +blind reviewers can identify stage claims, transcript events, openings, +sumcheck drivers, relation checks, and error paths from emitted Rust alone +reviewers do not need to inspect Bolt lowering or emitter code to understand +the generated verifier's security boundary +reviewers prefer the new generated verifier shape over the current generated +shape for auditability, or remaining objections are converted into tracked +cleanup items +``` + Perf remains a regression guard, not the center of this task. The existing `sha2-chain` e2e/proving Perfetto traces are useful for confirming cleanup does not accidentally move prover cost, but the main objective is verifier @@ -371,7 +508,10 @@ score = + fewer generated helper bodies + stronger negative oracles + clearer verifier.rs ++ clearer stage files under blind review ++ more verifier facts represented as typed plans - semantic opacity introduced into runtime +- compiler-context required to audit emitted Rust ``` ## Definition Of Done @@ -384,10 +524,13 @@ verifier.rs is <= 500 LOC stage files are mostly declarative plans generic verifier mechanics live once Jolt relation semantics are typed and auditable +field expressions and program steps use typed plan data +remaining string symbols are diagnostic or explicitly allowlisted MLIR verifier pathway has malformed-input rejection tests tamper suite covers commitments, transcript, stages, openings, evals, and PCS proof core/Bolt accept/reject equivalence is preserved generated verifier import boundaries are enforced +independent blind readability review passes ``` The desired end state is not merely fewer lines. The verifier should be easy to diff --git a/crates/bolt/src/protocols/jolt/artifacts.rs b/crates/bolt/src/protocols/jolt/artifacts.rs index 723d0e0ab9..c69d77ccb0 100644 --- a/crates/bolt/src/protocols/jolt/artifacts.rs +++ b/crates/bolt/src/protocols/jolt/artifacts.rs @@ -337,7 +337,7 @@ fn jolt_evaluation_role_api_extension() -> ProtocolArtifactExtension { required_artifact_stages: vec!["stage8".to_owned()], prover: ProtocolProverApiExtension { lib_module: jolt_prover_lib_module(), - imports: "#![expect(\n clippy::too_many_arguments,\n reason = \"generated prover helpers mirror staged protocol ABIs\"\n)]\n\nuse jolt_dory::{DoryCommitment, DoryHint, DoryProverSetup, DoryScheme};\nuse jolt_field::Fr;\nuse jolt_kernels::{stage1, stage2, stage3, stage4, stage5, stage6, stage7};\nuse jolt_openings::CommitmentScheme;\nuse jolt_poly::{EqPolynomial, Polynomial};\nuse jolt_transcript::{AppendToTranscript, Blake2bTranscript, LabelWithCount, Transcript};\nuse jolt_verifier::{JoltEvaluationProof, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput};\nuse jolt_witness::{stage4_ram_val_init_opening, CycleInput, Stage45SparseTraceWitness, Stage6BytecodeEntry as WitnessStage6BytecodeEntry, Stage6WitnessParams, Stage6WitnessPolynomials, Stage6WitnessSlices};\nuse rayon::prelude::*;\n\n".to_owned(), + imports: "#![expect(\n clippy::too_many_arguments,\n reason = \"generated prover helpers mirror staged protocol ABIs\"\n)]\n\nuse jolt_dory::{DoryCommitment, DoryHint, DoryProverSetup, DoryScheme};\nuse jolt_field::Fr;\nuse jolt_kernels::{stage1, stage2, stage3, stage4, stage5, stage6, stage7};\nuse jolt_openings::{AdditivelyHomomorphic, CommitmentScheme};\nuse jolt_poly::{EqPolynomial, Polynomial};\nuse jolt_transcript::{Blake2bTranscript, Transcript};\nuse jolt_verifier::{JoltEvaluationProof, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput};\nuse jolt_witness::{stage4_ram_val_init_opening, CycleInput, Stage45SparseTraceWitness, Stage6BytecodeEntry as WitnessStage6BytecodeEntry, Stage6WitnessParams, Stage6WitnessPolynomials, Stage6WitnessSlices};\nuse rayon::prelude::*;\n\n".to_owned(), input_fields: " pub stage7_openings: Option<&'a [stage7::Stage7OpeningInputValue]>,\n" .to_owned(), @@ -357,7 +357,7 @@ fn jolt_evaluation_role_api_extension() -> ProtocolArtifactExtension { }, verifier: ProtocolVerifierApiExtension { lib_module: jolt_verifier_lib_module(), - imports: "use std::collections::BTreeMap;\n\nuse jolt_dory::{DoryCommitment, DoryProof, DoryScheme, DoryVerifierSetup};\nuse jolt_field::Fr;\nuse jolt_openings::{AdditivelyHomomorphic, CommitmentScheme, OpeningsError};\nuse jolt_poly::EqPolynomial;\nuse jolt_transcript::{AppendToTranscript, LabelWithCount, Transcript};\n".to_owned(), + imports: "use std::collections::BTreeMap;\n\nuse jolt_dory::{DoryCommitment, DoryProof, DoryScheme, DoryVerifierSetup};\nuse jolt_field::Fr;\nuse jolt_openings::{AdditivelyHomomorphic, CommitmentScheme, OpeningsError};\nuse jolt_poly::EqPolynomial;\nuse jolt_transcript::Transcript;\n".to_owned(), proof_fields: " pub evaluation: Option,\n".to_owned(), proof_items: "pub type JoltStage2RamAccess = crate::stages::stage2::Stage2RamAccess;\npub type JoltStage2RamOutputLayout = crate::stages::stage2::Stage2RamOutputLayout;\npub type JoltStage2RamData<'a> = crate::stages::stage2::Stage2RamData<'a>;\npub type JoltStageChallengeVector = crate::stages::common::StageChallengeVector;\npub type JoltStageExecutionArtifacts = crate::stages::common::StageExecutionArtifacts;\npub type JoltStageOpeningInputValue = crate::stages::common::StageOpeningInputValue;\n\n#[derive(Clone, Debug)]\npub struct JoltEvaluationProof {\n pub joint_opening_proof: DoryProof,\n}\n\n".to_owned(), inputs_derive: Some("#[derive(Clone, Copy)]".to_owned()), @@ -405,6 +405,59 @@ fn jolt_verifier_evaluation_helpers(prefix: &str, field_type: &str) -> String { pub type {prefix}Stage6BytecodeReadRafData = crate::stages::stage6::Stage6BytecodeReadRafData; pub type {prefix}Stage6VerifierData = crate::stages::stage6::Stage6VerifierData; +impl stage8_stage::Stage8NamedEvalView<{field_type}> for {prefix}NamedEval {{ + fn name(&self) -> &'static str {{ + self.name + }} + + fn value(&self) -> {field_type} {{ + self.value + }} +}} + +impl stage8_stage::Stage8SumcheckOutputView<{field_type}> for {prefix}SumcheckOutput {{ + type Eval = {prefix}NamedEval; + + fn point(&self) -> &[{field_type}] {{ + &self.point + }} + + fn evals(&self) -> &[Self::Eval] {{ + &self.evals + }} +}} + +impl stage8_stage::Stage8OpeningInputView<{field_type}> + for stage7_stage::Stage7OpeningInputValue<{field_type}> +{{ + fn symbol(&self) -> &'static str {{ + self.symbol + }} + + fn point(&self) -> &[{field_type}] {{ + &self.point + }} +}} + +impl From for {prefix}EvaluationProofError {{ + fn from(error: stage8_stage::Stage8EvaluationOpeningPointError) -> Self {{ + match error {{ + stage8_stage::Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint => {{ + Self::MissingStage7EvaluationPoint + }} + stage8_stage::Stage8EvaluationOpeningPointError::InvalidPointLength {{ + artifact, + expected, + actual, + }} => Self::InvalidPointLength {{ + artifact, + expected, + actual, + }}, + }} + }} +}} + #[expect( clippy::too_many_arguments, reason = "generated verifier entry point follows the Jolt proof artifact boundary" @@ -452,11 +505,6 @@ struct EvaluationProofState {{ joint_commitment: DoryCommitment, }} -struct EvaluationClaim {{ - oracle: &'static str, - value: {field_type}, -}} - fn evaluation_proof_state( program: &'static stage8_stage::Stage8EvaluationProgramPlan, commitments: &commitment_stage::CommitmentArtifacts, @@ -468,14 +516,22 @@ fn evaluation_proof_state( where T: Transcript, {{ - let (sumcheck_address_point, stage7_values) = stage7_claim_values(program, stage7)?; - let address_point = reverse_point(&sumcheck_address_point); - let opening_point = stage7_evaluation_opening_point(program, &address_point, stage7_openings)?; + let (sumcheck_address_point, stage7_values) = + stage8_stage::stage7_claim_values(program, &stage7.sumchecks) + .ok_or({prefix}EvaluationProofError::MissingStage7RaEval)?; + let address_point = stage8_stage::reverse_point(&sumcheck_address_point); + let (opening_point, _) = + stage8_stage::stage7_evaluation_opening_point(program, &address_point, stage7_openings)?; let lagrange_factor = EqPolynomial::<{field_type}>::zero_selector(&address_point); - let claims = evaluation_claims(program, stage6, &stage7_values, lagrange_factor)?; - - append_rlc_claims(transcript, &claims); - let gamma_powers = gamma_powers(transcript, claims.len()); + let claims = + stage8_stage::evaluation_claims(program, &stage6.sumchecks, &stage7_values, lagrange_factor) + .map_err(|error| {prefix}EvaluationProofError::MissingStageEval {{ + stage: error.stage, + eval: error.eval, + }})?; + + stage8_stage::append_rlc_claims(transcript, &claims); + let gamma_powers = stage8_stage::gamma_powers(transcript, claims.len()); let joint_claim = claims .iter() .zip(&gamma_powers) @@ -490,130 +546,9 @@ where }}) }} -fn stage_eval( - proof: &{prefix}StageProof, - stage: &'static str, - eval_name: &'static str, -) -> Result<{field_type}, {prefix}EvaluationProofError> {{ - for output in &proof.sumchecks {{ - if let Some(eval) = output.evals.iter().find(|eval| eval.name == eval_name) {{ - return Ok(eval.value); - }} - }} - Err({prefix}EvaluationProofError::MissingStageEval {{ - stage, - eval: eval_name, - }}) -}} - -fn evaluation_claims( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - stage6: &{prefix}StageProof, - stage7_values: &BTreeMap<&'static str, {field_type}>, - lagrange_factor: {field_type}, -) -> Result, {prefix}EvaluationProofError> {{ - let mut claims = Vec::with_capacity(program.opening_claims.len()); - for plan in program.opening_claims {{ - let value = match plan.source_stage {{ - "stage6" => stage_eval(stage6, plan.source_stage, plan.source_claim)? * lagrange_factor, - "stage7" => *stage7_values.get(plan.source_claim).ok_or( - {prefix}EvaluationProofError::MissingStageEval {{ - stage: plan.source_stage, - eval: plan.source_claim, - }}, - )?, - _ => {{ - return Err({prefix}EvaluationProofError::MissingStageEval {{ - stage: plan.source_stage, - eval: plan.source_claim, - }}); - }} - }}; - claims.push(EvaluationClaim {{ - oracle: plan.oracle, - value, - }}); - }} - Ok(claims) -}} - -fn stage7_claim_values( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - proof: &{prefix}StageProof, -) -> Result<(Vec<{field_type}>, BTreeMap<&'static str, {field_type}>), {prefix}EvaluationProofError> {{ - let stage7_plans = program - .opening_claims - .iter() - .filter(|plan| plan.source_stage == "stage7") - .collect::>(); - for output in &proof.sumchecks {{ - let mut values = BTreeMap::new(); - for plan in &stage7_plans {{ - if let Some(eval) = output.evals.iter().find(|eval| eval.name == plan.source_claim) {{ - let _ = values.insert(plan.source_claim, eval.value); - }} - }} - if values.len() == stage7_plans.len() {{ - return Ok((output.point.clone(), values)); - }} - }} - Err({prefix}EvaluationProofError::MissingStage7RaEval) -}} - -fn reverse_point(point: &[{field_type}]) -> Vec<{field_type}> {{ - point.iter().rev().copied().collect() -}} - -fn stage7_evaluation_opening_point( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - address_point: &[{field_type}], - stage7_openings: &[stage7_stage::Stage7OpeningInputValue<{field_type}>], -) -> Result, {prefix}EvaluationProofError> {{ - let cycle_source_symbol = program.evaluation_point_source.source_claim; - let cycle_source = stage7_openings - .iter() - .find(|input| input.symbol == cycle_source_symbol) - .ok_or({prefix}EvaluationProofError::MissingStage7EvaluationPoint)?; - if cycle_source.point.len() < address_point.len() {{ - return Err({prefix}EvaluationProofError::InvalidPointLength {{ - artifact: cycle_source_symbol, - expected: address_point.len(), - actual: cycle_source.point.len(), - }}); - }} - let mut point = Vec::with_capacity(cycle_source.point.len()); - point.extend_from_slice(address_point); - point.extend_from_slice(&cycle_source.point[address_point.len()..]); - Ok(point) -}} - -fn append_rlc_claims(transcript: &mut T, claims: &[EvaluationClaim]) -where - T: Transcript, -{{ - transcript.append(&LabelWithCount(b"rlc_claims", claims.len() as u64)); - for claim in claims {{ - claim.value.append_to_transcript(transcript); - }} -}} - -fn gamma_powers(transcript: &mut T, count: usize) -> Vec<{field_type}> -where - T: Transcript, -{{ - let gamma = transcript.challenge(); - let mut powers = Vec::with_capacity(count); - let mut power = {field_type}::from_u64(1); - for _ in 0..count {{ - powers.push(power); - power *= gamma; - }} - powers -}} - fn joint_commitment( commitments: &commitment_stage::CommitmentArtifacts, - claims: &[EvaluationClaim], + claims: &[stage8_stage::Stage8EvaluationClaim<{field_type}>], gamma_powers: &[{field_type}], ) -> Result {{ let mut coefficients = BTreeMap::<&'static str, {field_type}>::new(); @@ -1996,7 +1931,62 @@ fn stage5_opening_claim( fn jolt_prover_evaluation_helpers(field_type: &str) -> String { format!( - r#"pub fn prove_jolt_evaluation_proof( + r#"impl stage8_stage::Stage8NamedEvalView<{field_type}> for stage7::Stage7NamedEval<{field_type}> {{ + fn name(&self) -> &'static str {{ + self.name + }} + + fn value(&self) -> {field_type} {{ + self.value + }} +}} + +impl stage8_stage::Stage8SumcheckOutputView<{field_type}> + for stage7::Stage7SumcheckOutput<{field_type}> +{{ + type Eval = stage7::Stage7NamedEval<{field_type}>; + + fn point(&self) -> &[{field_type}] {{ + &self.point + }} + + fn evals(&self) -> &[Self::Eval] {{ + &self.evals + }} +}} + +impl stage8_stage::Stage8OpeningInputView<{field_type}> + for stage7::Stage7OpeningInputValue<{field_type}> +{{ + fn symbol(&self) -> &'static str {{ + self.symbol + }} + + fn point(&self) -> &[{field_type}] {{ + &self.point + }} +}} + +impl From for JoltEvaluationProveError {{ + fn from(error: stage8_stage::Stage8EvaluationOpeningPointError) -> Self {{ + match error {{ + stage8_stage::Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint => {{ + Self::MissingStage7EvaluationPoint + }} + stage8_stage::Stage8EvaluationOpeningPointError::InvalidPointLength {{ + artifact, + expected, + actual, + }} => Self::InvalidPointLength {{ + artifact, + expected, + actual, + }}, + }} + }} +}} + +pub fn prove_jolt_evaluation_proof( program: &'static stage8_stage::Stage8EvaluationProgramPlan, commitment_inputs: &mut I, prover_setup: &DoryProverSetup, @@ -2011,17 +2001,24 @@ where T: Transcript, {{ let _claims_span = tracing::info_span!("bolt.evaluate.claims").entered(); - let (sumcheck_address_point, stage7_values) = stage7_claim_values(program, stage7)?; - let address_point = reverse_point(&sumcheck_address_point); + let (sumcheck_address_point, stage7_values) = + stage8_stage::stage7_claim_values(program, &stage7.sumchecks) + .ok_or(JoltEvaluationProveError::MissingStage7RaEval)?; + let address_point = stage8_stage::reverse_point(&sumcheck_address_point); let (opening_point, log_t) = - stage7_evaluation_opening_point(program, &address_point, stage7_openings)?; + stage8_stage::stage7_evaluation_opening_point(program, &address_point, stage7_openings)?; let lagrange_factor = EqPolynomial::<{field_type}>::zero_selector(&address_point); - let claims = evaluation_claims(program, stage6, &stage7_values, lagrange_factor)?; + let claims = + stage8_stage::evaluation_claims(program, &stage6.sumchecks, &stage7_values, lagrange_factor) + .map_err(|error| JoltEvaluationProveError::MissingStageEval {{ + stage: error.stage, + eval: error.eval, + }})?; drop(_claims_span); let _rlc_span = tracing::info_span!("bolt.evaluate.rlc_claims").entered(); - append_rlc_claims(transcript, &claims); - let gamma_powers = gamma_powers(transcript, claims.len()); + stage8_stage::append_rlc_claims(transcript, &claims); + let gamma_powers = stage8_stage::gamma_powers(transcript, claims.len()); let joint_claim = claims .iter() .zip(&gamma_powers) @@ -2062,137 +2059,9 @@ where Ok(JoltEvaluationProof {{ joint_opening_proof }}) }} -struct EvaluationClaim {{ - oracle: &'static str, - source_stage: &'static str, - value: {field_type}, -}} - -fn stage6_eval_claim( - artifacts: &stage6::Stage6ExecutionArtifacts<{field_type}>, - eval_name: &'static str, -) -> Result<{field_type}, JoltEvaluationProveError> {{ - for output in &artifacts.sumchecks {{ - if let Some(eval) = output.evals.iter().find(|eval| eval.name == eval_name) {{ - return Ok(eval.value); - }} - }} - Err(JoltEvaluationProveError::MissingStageEval {{ - stage: "stage6", - eval: eval_name, - }}) -}} - -fn evaluation_claims( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - stage6: &stage6::Stage6ExecutionArtifacts<{field_type}>, - stage7_values: &std::collections::BTreeMap<&'static str, {field_type}>, - lagrange_factor: {field_type}, -) -> Result, JoltEvaluationProveError> {{ - let mut claims = Vec::with_capacity(program.opening_claims.len()); - for plan in program.opening_claims {{ - let value = match plan.source_stage {{ - "stage6" => stage6_eval_claim(stage6, plan.source_claim)? * lagrange_factor, - "stage7" => *stage7_values.get(plan.source_claim).ok_or( - JoltEvaluationProveError::MissingStageEval {{ - stage: plan.source_stage, - eval: plan.source_claim, - }}, - )?, - _ => {{ - return Err(JoltEvaluationProveError::MissingStageEval {{ - stage: plan.source_stage, - eval: plan.source_claim, - }}); - }} - }}; - claims.push(EvaluationClaim {{ - oracle: plan.oracle, - source_stage: plan.source_stage, - value, - }}); - }} - Ok(claims) -}} - -fn stage7_claim_values( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - artifacts: &stage7::Stage7ExecutionArtifacts<{field_type}>, -) -> Result<(Vec<{field_type}>, std::collections::BTreeMap<&'static str, {field_type}>), JoltEvaluationProveError> {{ - let stage7_plans = program - .opening_claims - .iter() - .filter(|plan| plan.source_stage == "stage7") - .collect::>(); - for output in &artifacts.sumchecks {{ - let mut values = std::collections::BTreeMap::new(); - for plan in &stage7_plans {{ - if let Some(eval) = output.evals.iter().find(|eval| eval.name == plan.source_claim) {{ - let _ = values.insert(plan.source_claim, eval.value); - }} - }} - if values.len() == stage7_plans.len() {{ - return Ok((output.point.clone(), values)); - }} - }} - Err(JoltEvaluationProveError::MissingStage7RaEval) -}} - -fn reverse_point(point: &[{field_type}]) -> Vec<{field_type}> {{ - point.iter().rev().copied().collect() -}} - -fn stage7_evaluation_opening_point( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - address_point: &[{field_type}], - stage7_openings: &[stage7::Stage7OpeningInputValue<{field_type}>], -) -> Result<(Vec<{field_type}>, usize), JoltEvaluationProveError> {{ - let cycle_source_symbol = program.evaluation_point_source.source_claim; - let cycle_source = stage7_openings - .iter() - .find(|input| input.symbol == cycle_source_symbol) - .ok_or(JoltEvaluationProveError::MissingStage7EvaluationPoint)?; - if cycle_source.point.len() < address_point.len() {{ - return Err(JoltEvaluationProveError::InvalidPointLength {{ - artifact: cycle_source_symbol, - expected: address_point.len(), - actual: cycle_source.point.len(), - }}); - }} - let cycle_len = cycle_source.point.len() - address_point.len(); - let mut point = Vec::with_capacity(cycle_source.point.len()); - point.extend_from_slice(address_point); - point.extend_from_slice(&cycle_source.point[address_point.len()..]); - Ok((point, cycle_len)) -}} - -fn append_rlc_claims(transcript: &mut T, claims: &[EvaluationClaim]) -where - T: Transcript, -{{ - transcript.append(&LabelWithCount(b"rlc_claims", claims.len() as u64)); - for claim in claims {{ - claim.value.append_to_transcript(transcript); - }} -}} - -fn gamma_powers(transcript: &mut T, count: usize) -> Vec<{field_type}> -where - T: Transcript, -{{ - let gamma = transcript.challenge(); - let mut powers = Vec::with_capacity(count); - let mut power = {field_type}::from_u64(1); - for _ in 0..count {{ - powers.push(power); - power *= gamma; - }} - powers -}} - fn materialize_joint_polynomial( commitment_inputs: &mut I, - claims: &[EvaluationClaim], + claims: &[stage8_stage::Stage8EvaluationClaim<{field_type}>], gamma_powers: &[{field_type}], log_t: usize, main_num_vars: usize, @@ -2204,7 +2073,7 @@ where let main_len = target_len(main_num_vars)?; let mut joint = vec![{field_type}::from_u64(0); main_len]; for (claim, gamma) in claims.iter().zip(gamma_powers) {{ - if claim.source_stage == "stage6" {{ + if claim.source_stage == stage8_stage::Stage8SourceStage::Stage6 {{ add_oracle_scaled(commitment_inputs, &mut joint, claim.oracle, log_t, trace_len, *gamma)?; }} else {{ add_oracle_scaled( @@ -2279,7 +2148,7 @@ where fn joint_opening_hint( commitments: &commitment_stage::CommitmentArtifacts, - claims: &[EvaluationClaim], + claims: &[stage8_stage::Stage8EvaluationClaim<{field_type}>], gamma_powers: &[{field_type}], ) -> Result {{ let mut coefficients = std::collections::BTreeMap::<&'static str, {field_type}>::new(); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/commitment.rs b/crates/bolt/src/protocols/jolt/emit/rust/commitment.rs index e5460c75c6..dcb1bceaad 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/commitment.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/commitment.rs @@ -1101,8 +1101,15 @@ pub enum CommitmentPhaseError { for (index, plan) in self.batch_plans.iter().enumerate() { let oracles = plan .oracles - .iter() - .map(|oracle| format!(" {},", rust_str(oracle))) + .chunks(8) + .map(|chunk| { + let entries = chunk + .iter() + .map(|oracle| rust_str(oracle)) + .collect::>() + .join(", "); + format!(" {entries},") + }) .collect::>() .join("\n"); push_format( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/mod.rs b/crates/bolt/src/protocols/jolt/emit/rust/mod.rs index 50f36ba9f7..00b7be9f4c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/mod.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/mod.rs @@ -1,4 +1,5 @@ mod commitment; +mod plan_tokens; mod stage1; mod stage2; mod stage3; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs new file mode 100644 index 0000000000..24f7015bdd --- /dev/null +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -0,0 +1,212 @@ +use crate::emit::rust::EmitError; +use crate::ir::Role; + +pub(super) fn role_program_step_kind_expr( + stage_type_prefix: &str, + role: &Role, + kind: &str, +) -> Result { + if role == &Role::Prover { + return Ok(format!("{kind:?}")); + } + program_step_kind_expr(stage_type_prefix, kind) +} + +pub(super) fn role_transcript_squeeze_kind_expr( + stage_type_prefix: &str, + role: &Role, + kind: &str, +) -> Result { + if role == &Role::Prover { + return Ok(format!("{kind:?}")); + } + transcript_squeeze_kind_expr(stage_type_prefix, kind) +} + +pub(super) fn role_claim_kind_expr( + stage_type_prefix: &str, + role: &Role, + kind: &str, +) -> Result { + if role == &Role::Prover { + return Ok(format!("{kind:?}")); + } + claim_kind_expr(stage_type_prefix, kind) +} + +pub(super) fn role_field_expr_kind_expr( + stage_type_prefix: &str, + role: &Role, + formula: &str, +) -> Result { + if role == &Role::Prover { + return Ok(format!("{formula:?}")); + } + field_expr_kind_expr(stage_type_prefix, formula) +} + +pub(super) fn role_relation_kind_expr( + stage_type_prefix: &str, + role: &Role, + relation: &str, +) -> Result { + if role == &Role::Prover { + return Ok(format!("{relation:?}")); + } + relation_kind_expr(stage_type_prefix, relation) +} + +pub(super) fn role_optional_relation_kind_expr( + stage_type_prefix: &str, + role: &Role, + relation: Option<&str>, +) -> Result { + relation + .map(|relation| role_relation_kind_expr(stage_type_prefix, role, relation)) + .transpose() + .map(|relation| { + relation.map_or_else(|| "None".to_owned(), |relation| format!("Some({relation})")) + }) +} + +pub(super) fn role_opening_equality_mode_expr( + stage_type_prefix: &str, + role: &Role, + mode: &str, +) -> Result { + if role == &Role::Prover { + return Ok(format!("{mode:?}")); + } + opening_equality_mode_expr(stage_type_prefix, mode) +} + +fn program_step_kind_expr(stage_type_prefix: &str, kind: &str) -> Result { + let variant = match kind { + "transcript_squeeze" => "TranscriptSqueeze", + "transcript_absorb_bytes" => "TranscriptAbsorbBytes", + "sumcheck_driver" => "SumcheckDriver", + _ => return Err(unsupported("program step kind", kind)), + }; + Ok(format!("{stage_type_prefix}ProgramStepKind::{variant}")) +} + +fn transcript_squeeze_kind_expr(stage_type_prefix: &str, kind: &str) -> Result { + let variant = match kind { + "challenge_scalar" => "ChallengeScalar", + "challenge_vector" => "ChallengeVector", + "scalar" => "Scalar", + _ => return Err(unsupported("transcript squeeze kind", kind)), + }; + Ok(format!( + "{stage_type_prefix}TranscriptSqueezeKind::{variant}" + )) +} + +pub(super) fn claim_kind_expr(stage_type_prefix: &str, kind: &str) -> Result { + let variant = match kind { + "committed" => "Committed", + "virtual" => "Virtual", + _ => return Err(unsupported("opening claim kind", kind)), + }; + Ok(format!("{stage_type_prefix}ClaimKind::{variant}")) +} + +fn relation_kind_expr(stage_type_prefix: &str, relation: &str) -> Result { + let variant = match relation { + "jolt.stage1.outer.uniskip" => "Stage1OuterUniskip", + "jolt.stage1.outer.remaining" => "Stage1OuterRemaining", + "jolt.stage2.product_virtual.uniskip" => "Stage2ProductVirtualUniskip", + "jolt.stage2.ram.read_write" => "Stage2RamReadWrite", + "jolt.stage2.product_virtual.remainder" => "Stage2ProductVirtualRemainder", + "jolt.stage2.instruction_lookup.claim_reduction" => "Stage2InstructionLookupClaimReduction", + "jolt.stage2.ram.raf_evaluation" => "Stage2RamRafEvaluation", + "jolt.stage2.ram.output_check" => "Stage2RamOutputCheck", + "jolt.stage2.batched" => "Stage2Batched", + "jolt.stage3.spartan_shift" => "Stage3SpartanShift", + "jolt.stage3.instruction_input" => "Stage3InstructionInput", + "jolt.stage3.registers_claim_reduction" => "Stage3RegistersClaimReduction", + "jolt.stage3.batched" => "Stage3Batched", + "jolt.stage4.registers_read_write" => "Stage4RegistersReadWrite", + "jolt.stage4.ram_val_check" => "Stage4RamValCheck", + "jolt.stage4.batched" => "Stage4Batched", + "jolt.stage5.instruction_read_raf" => "Stage5InstructionReadRaf", + "jolt.stage5.ram_ra_claim_reduction" => "Stage5RamRaClaimReduction", + "jolt.stage5.registers_val_evaluation" => "Stage5RegistersValEvaluation", + "jolt.stage5.batched" => "Stage5Batched", + "jolt.stage6.bytecode_read_raf" => "Stage6BytecodeReadRaf", + "jolt.stage6.booleanity" => "Stage6Booleanity", + "jolt.stage6.hamming_booleanity" => "Stage6HammingBooleanity", + "jolt.stage6.ram_ra_virtual" => "Stage6RamRaVirtual", + "jolt.stage6.instruction_ra_virtual" => "Stage6InstructionRaVirtual", + "jolt.stage6.inc_claim_reduction" => "Stage6IncClaimReduction", + "jolt.stage6.batched" => "Stage6Batched", + "jolt.stage7.hamming_weight_claim_reduction" => "Stage7HammingWeightClaimReduction", + "jolt.stage7.batched" => "Stage7Batched", + _ => return Err(unsupported("relation", relation)), + }; + Ok(format!("{stage_type_prefix}RelationKind::{variant}")) +} + +fn field_expr_kind_expr(stage_type_prefix: &str, formula: &str) -> Result { + let variant = match formula { + "opening_eval" => "OpeningEval".to_owned(), + "field.add" => "Add".to_owned(), + "field.sub" => "Sub".to_owned(), + "field.mul" => "Mul".to_owned(), + "field.neg" => "Neg".to_owned(), + formula if formula.starts_with("field.pow:") => { + let Some(exponent) = formula.strip_prefix("field.pow:") else { + return Err(unsupported("field expression formula", formula)); + }; + let exponent = exponent + .parse::() + .map_err(|_| unsupported("field expression formula", formula))?; + format!("Pow({exponent})") + } + formula if formula.starts_with("poly.lagrange_basis_eval:") => { + let Some(spec) = formula.strip_prefix("poly.lagrange_basis_eval:") else { + return Err(unsupported("field expression formula", formula)); + }; + let parts = spec.split(':').collect::>(); + if parts.len() != 3 { + return Err(unsupported("field expression formula", formula)); + } + let domain_start = parts[0] + .parse::() + .map_err(|_| unsupported("field expression formula", formula))?; + let domain_size = parts[1] + .parse::() + .map_err(|_| unsupported("field expression formula", formula))?; + let index = parts[2] + .parse::() + .map_err(|_| unsupported("field expression formula", formula))?; + format!("LagrangeBasisEval({domain_start}, {domain_size}, {index})") + } + _ => return Err(unsupported("field expression formula", formula)), + }; + Ok(format!("{stage_type_prefix}FieldExprKind::{variant}")) +} + +pub(super) fn pcs_proof_mode_expr( + stage_type_prefix: &str, + mode: &str, +) -> Result { + let variant = match mode { + "open" => "Open", + "verify" => "Verify", + _ => return Err(unsupported("PCS proof mode", mode)), + }; + Ok(format!("{stage_type_prefix}PcsProofMode::{variant}")) +} + +fn opening_equality_mode_expr(stage_type_prefix: &str, mode: &str) -> Result { + let variant = match mode { + "point_and_eval" => "PointAndEval", + _ => return Err(unsupported("opening equality mode", mode)), + }; + Ok(format!("{stage_type_prefix}OpeningEqualityMode::{variant}")) +} + +fn unsupported(kind: &str, value: &str) -> EmitError { + EmitError::new(format!("unsupported {kind} `{value}`")) +} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs index 9975b41010..99b6f87b17 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs @@ -709,25 +709,21 @@ impl Stage1CpuProgram { push_format( &mut source, format_args!( - "pub const STAGE1_PARAMS: Stage1Params = Stage1Params {{\n\ - \x20 field: {},\n\ - \x20 pcs: {},\n\ - \x20 transcript: {},\n\ - }};\n", + "pub const STAGE1_PARAMS: Stage1Params = Stage1Params {{ field: {}, pcs: {}, transcript: {} }};\n", rust_str(&self.params.field), rust_str(&self.params.pcs), rust_str(&self.params.transcript) ), ); - source.push_str(&self.emit_transcript_squeeze_constants()); + source.push_str(&self.emit_transcript_squeeze_constants()?); source.push_str(&self.emit_kernel_constants()); source.push_str(&self.emit_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_sumcheck_driver_constants()?); - source.push_str(&self.emit_sumcheck_instance_result_constants()); + source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); - source.push_str(&self.emit_opening_claim_constants()); + source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_batch_constants()); source.push_str( "pub const STAGE1_PROGRAM: Stage1CpuProgramPlan = Stage1CpuProgramPlan {\n\ @@ -746,50 +742,58 @@ impl Stage1CpuProgram { Ok(source) } - fn emit_sumcheck_instance_result_constants(&self) -> String { + fn emit_sumcheck_instance_result_constants(&self) -> Result { let instances = self .instance_results .iter() .map(|instance| { - format!( + Ok(format!( " Stage1SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},", rust_str(&instance.symbol), rust_str(&instance.source), rust_str(&instance.claim), - rust_str(&instance.relation), + super::plan_tokens::role_relation_kind_expr( + "Stage1", + &self.role, + &instance.relation + )?, instance.index, instance.point_arity, instance.num_rounds, instance.round_offset, rust_str(&instance.point_order), instance.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE1_SUMCHECK_INSTANCE_RESULTS: &[Stage1SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n" - ) + )) } - fn emit_transcript_squeeze_constants(&self) -> String { + fn emit_transcript_squeeze_constants(&self) -> Result { let squeezes = self .transcript_squeezes .iter() .map(|squeeze| { - format!( + Ok(format!( " Stage1TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},", rust_str(&squeeze.symbol), rust_str(&squeeze.label), - rust_str(&squeeze.kind), + super::plan_tokens::role_transcript_squeeze_kind_expr( + "Stage1", + &self.role, + &squeeze.kind + )?, squeeze.count, - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE1_TRANSCRIPT_SQUEEZES: &[Stage1TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n" - ) + )) } fn emit_kernel_constants(&self) -> String { @@ -984,25 +988,27 @@ impl Stage1CpuProgram { format!("pub const STAGE1_SUMCHECK_EVALS: &[Stage1SumcheckEvalPlan] = &[\n{evals}\n];\n\n") } - fn emit_opening_claim_constants(&self) -> String { + fn emit_opening_claim_constants(&self) -> Result { let claims = self .opening_claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage1OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},", rust_str(&claim.symbol), rust_str(&claim.oracle), rust_str(&claim.domain), claim.point_arity, - rust_str(&claim.claim_kind), + super::plan_tokens::role_claim_kind_expr("Stage1", &self.role, &claim.claim_kind)?, rust_str(&claim.point_source), rust_str(&claim.eval_source) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE1_OPENING_CLAIMS: &[Stage1OpeningClaimPlan] = &[\n{claims}\n];\n\n") + Ok(format!( + "pub const STAGE1_OPENING_CLAIMS: &[Stage1OpeningClaimPlan] = &[\n{claims}\n];\n\n" + )) } fn emit_opening_batch_constants(&self) -> String { @@ -1084,9 +1090,11 @@ pub type Stage1Proof = super::common::StageProof; pub type Stage1VerifierProgramPlan = super::common::VerifierProgramPlanMinimal; pub use super::common::{ - OpeningBatchPlan as Stage1OpeningBatchPlan, OpeningClaimPlan as Stage1OpeningClaimPlan, + ClaimKind as Stage1ClaimKind, RelationKind as Stage1RelationKind, OpeningBatchPlan as Stage1OpeningBatchPlan, + OpeningClaimPlan as Stage1OpeningClaimPlan, SumcheckBatchPlan as Stage1SumcheckBatchPlan, SumcheckEvalPlan as Stage1SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage1SumcheckInstanceResultPlan, + TranscriptSqueezeKind as Stage1TranscriptSqueezeKind, TranscriptSqueezePlan as Stage1TranscriptSqueezePlan, SumcheckClaimPlan as Stage1SumcheckClaimPlan, SumcheckDriverPlan as Stage1SumcheckDriverPlan, @@ -1100,7 +1108,7 @@ pub enum VerifyStage1Error { MissingClaim { driver: &'static str, claim: &'static str }, MissingDependency { driver: &'static str, dependency: &'static str }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage1RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } " @@ -1111,24 +1119,20 @@ pub enum VerifyStage1Error { push_format( &mut source, format_args!( - "pub const STAGE1_PARAMS: Stage1Params = Stage1Params {{\n\ - \x20 field: {},\n\ - \x20 pcs: {},\n\ - \x20 transcript: {},\n\ - }};\n", + "pub const STAGE1_PARAMS: Stage1Params = Stage1Params {{ field: {}, pcs: {}, transcript: {} }};\n", rust_str(&self.params.field), rust_str(&self.params.pcs), rust_str(&self.params.transcript) ), ); - source.push_str(&self.emit_transcript_squeeze_constants()); + source.push_str(&self.emit_transcript_squeeze_constants()?); source.push_str(&self.emit_verifier_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_verifier_sumcheck_driver_constants()?); - source.push_str(&self.emit_sumcheck_instance_result_constants()); + source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); - source.push_str(&self.emit_opening_claim_constants()); + source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_batch_constants()); source.push_str( "pub const STAGE1_PROGRAM: Stage1VerifierProgramPlan = Stage1VerifierProgramPlan {\n\ @@ -1161,7 +1165,11 @@ pub enum VerifyStage1Error { claim.num_rounds, claim.degree, rust_str(&claim.claim), - rust_str(relation), + super::plan_tokens::role_relation_kind_expr( + "Stage1", + &self.role, + relation + )?, rust_str(&claim.claim_value), rust_str(&claim.input_openings.join("|")) )); @@ -1191,7 +1199,11 @@ pub enum VerifyStage1Error { rust_str(&driver.symbol), rust_str(&driver.stage), rust_str(&driver.proof_slot), - rust_str(relation), + super::plan_tokens::role_relation_kind_expr( + "Stage1", + &self.role, + relation + )?, rust_str(&driver.batch), rust_str(&driver.policy), rust_str(&driver.claim_label), @@ -1307,10 +1319,17 @@ where reason: "driver symbol mismatch", }); } - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage1Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; match relation { - "jolt.stage1.outer.uniskip" => verify_outer_uniskip(program, driver, proof, transcript), - "jolt.stage1.outer.remaining" => { + Stage1RelationKind::Stage1OuterUniskip => { + verify_outer_uniskip(program, driver, proof, transcript) + } + Stage1RelationKind::Stage1OuterRemaining => { verify_outer_remaining(program, driver, proof, completed, transcript) } relation => Err(VerifyStage1Error::UnsupportedRelation { relation }), @@ -1497,10 +1516,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String { fn emit_usize_array(name: &str, values: &[usize]) -> String { let entries = values .iter() - .map(|value| format!(" {value},")) + .map(usize::to_string) .collect::>() - .join("\n"); - format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n") + .join(", "); + format!("pub const {name}: &[usize] = &[{entries}];\n\n") } fn rust_str(value: &str) -> String { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index b7c3f61d63..f3b73cc8b3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -926,7 +926,7 @@ impl Stage2CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, pow_field, require_operand_count, reverse_slice, single_operand};\n\ + "use super::common::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt, RingCore};\n\ use jolt_poly::lagrange::{lagrange_evals, lagrange_kernel_eval};\n\ use jolt_poly::{EqPolynomial, UnivariatePoly};\n\ @@ -946,13 +946,17 @@ pub type Stage2OpeningInputValue = super::common::StageOpeningInputValue; pub type Stage2VerifierProgramPlan = super::common::StageVerifierProgramPlanNoEqualities; pub use super::common::{ - FieldConstantPlan as Stage2FieldConstantPlan, FieldExprPlan as Stage2FieldExprPlan, + ClaimKind as Stage2ClaimKind, RelationKind as Stage2RelationKind, FieldConstantPlan as Stage2FieldConstantPlan, + FieldExprKind as Stage2FieldExprKind, + FieldExprPlan as Stage2FieldExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, OpeningInputPlan as Stage2OpeningInputPlan, PointConcatPlan as Stage2PointConcatPlan, - PointSlicePlan as Stage2PointSlicePlan, ProgramStepPlan as Stage2ProgramStepPlan, - StageParams as Stage2Params, SumcheckBatchPlan as Stage2SumcheckBatchPlan, + PointSlicePlan as Stage2PointSlicePlan, ProgramStepKind as Stage2ProgramStepKind, + ProgramStepPlan as Stage2ProgramStepPlan, StageParams as Stage2Params, + SumcheckBatchPlan as Stage2SumcheckBatchPlan, SumcheckEvalPlan as Stage2SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage2SumcheckInstanceResultPlan, + TranscriptSqueezeKind as Stage2TranscriptSqueezeKind, TranscriptSqueezePlan as Stage2TranscriptSqueezePlan, SumcheckClaimPlan as Stage2SumcheckClaimPlan, SumcheckDriverPlan as Stage2SumcheckDriverPlan, @@ -993,8 +997,7 @@ pub enum VerifyStage2Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage2RelationKind }, MissingRam { relation: &'static str }, Sumcheck { driver: &'static str, error: SumcheckError }, } @@ -1004,12 +1007,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); } fn emit_prover_constants(&self) -> Result { - let mut source = self.emit_shared_constants(); + let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_kernel_constants()); source.push_str(&self.emit_prover_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_prover_sumcheck_driver_constants()?); - source.push_str(&self.emit_tail_constants()); + source.push_str(&self.emit_tail_constants()?); source.push_str( "pub const STAGE2_PROGRAM: Stage2CpuProgramPlan = Stage2CpuProgramPlan {\n\ \x20 params: STAGE2_PARAMS,\n\ @@ -1034,11 +1037,11 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); } fn emit_verifier_constants(&self) -> Result { - let mut source = self.emit_shared_constants(); + let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_verifier_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_verifier_sumcheck_driver_constants()?); - source.push_str(&self.emit_tail_constants()); + source.push_str(&self.emit_tail_constants()?); source.push_str( "pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan {\n\ \x20 params: STAGE2_PARAMS,\n\ @@ -1061,71 +1064,75 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); Ok(source) } - fn emit_shared_constants(&self) -> String { + fn emit_shared_constants(&self) -> Result { let mut source = String::new(); push_format( &mut source, format_args!( - "pub const STAGE2_PARAMS: Stage2Params = Stage2Params {{\n\ - \x20 field: {},\n\ - \x20 pcs: {},\n\ - \x20 transcript: {},\n\ - }};\n", + "pub const STAGE2_PARAMS: Stage2Params = Stage2Params {{ field: {}, pcs: {}, transcript: {} }};\n", rust_str(&self.params.field), rust_str(&self.params.pcs), rust_str(&self.params.transcript) ), ); - source.push_str(&self.emit_program_step_constants()); - source.push_str(&self.emit_transcript_squeeze_constants()); - source.push_str(&self.emit_opening_input_constants()); + source.push_str(&self.emit_program_step_constants()?); + source.push_str(&self.emit_transcript_squeeze_constants()?); + source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); - source.push_str(&self.emit_field_expr_constants()); - source + source.push_str(&self.emit_field_expr_constants()?); + Ok(source) } - fn emit_program_step_constants(&self) -> String { + fn emit_program_step_constants(&self) -> Result { let steps = self .steps .iter() .map(|step| { - format!( + Ok(format!( " Stage2ProgramStepPlan {{ kind: {}, symbol: {} }},", - rust_str(&step.kind), + super::plan_tokens::role_program_step_kind_expr( + "Stage2", &self.role, &step.kind + )?, rust_str(&step.symbol), - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE2_PROGRAM_STEPS: &[Stage2ProgramStepPlan] = &[\n{steps}\n];\n\n") + Ok(format!( + "pub const STAGE2_PROGRAM_STEPS: &[Stage2ProgramStepPlan] = &[\n{steps}\n];\n\n" + )) } - fn emit_transcript_squeeze_constants(&self) -> String { + fn emit_transcript_squeeze_constants(&self) -> Result { let squeezes = self .transcript_squeezes .iter() .map(|squeeze| { - format!( + Ok(format!( " Stage2TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},", rust_str(&squeeze.symbol), rust_str(&squeeze.label), - rust_str(&squeeze.kind), + super::plan_tokens::role_transcript_squeeze_kind_expr( + "Stage2", + &self.role, + &squeeze.kind + )?, squeeze.count, - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE2_TRANSCRIPT_SQUEEZES: &[Stage2TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n" - ) + )) } - fn emit_opening_input_constants(&self) -> String { + fn emit_opening_input_constants(&self) -> Result { let inputs = self .opening_inputs .iter() .map(|input| { - format!( + Ok(format!( " Stage2OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},", rust_str(&input.symbol), rust_str(&input.source_stage), @@ -1133,12 +1140,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); rust_str(&input.oracle), rust_str(&input.domain), input.point_arity, - rust_str(&input.claim_kind) - ) + super::plan_tokens::role_claim_kind_expr("Stage2", &self.role, &input.claim_kind)? + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE2_OPENING_INPUTS: &[Stage2OpeningInputPlan] = &[\n{inputs}\n];\n\n") + Ok(format!( + "pub const STAGE2_OPENING_INPUTS: &[Stage2OpeningInputPlan] = &[\n{inputs}\n];\n\n" + )) } fn emit_field_constant_constants(&self) -> String { @@ -1160,25 +1169,28 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); ) } - fn emit_field_expr_constants(&self) -> String { + fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { let exprs = self .field_exprs .iter() .map(|expr| { - format!( - " Stage2FieldExprPlan {{ symbol: {}, kind: {}, formula: {}, operands: {} }},", + Ok(format!( + " Stage2FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", rust_str(&expr.symbol), - rust_str(&expr.kind), - rust_str(&expr.formula), + super::plan_tokens::role_field_expr_kind_expr( + "Stage2", + &self.role, + &expr.formula + )?, rust_str(&expr.operands.join("|")) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - return format!( + return Ok(format!( "pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[\n{exprs}\n];\n" - ); + )); } let mut source = String::new(); @@ -1220,7 +1232,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); "pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[\n{exprs}\n];\n" ), ); - source + Ok(source) } fn emit_kernel_constants(&self) -> String { @@ -1290,7 +1302,11 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); claim.num_rounds, claim.degree, rust_str(&claim.claim), - rust_str(relation), + super::plan_tokens::role_relation_kind_expr( + "Stage2", + &self.role, + relation + )?, rust_str(&claim.claim_value), rust_str(&claim.input_openings.join("|")) )); @@ -1431,7 +1447,11 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); rust_str(&driver.symbol), rust_str(&driver.stage), rust_str(&driver.proof_slot), - rust_str(relation), + super::plan_tokens::role_relation_kind_expr( + "Stage2", + &self.role, + relation + )?, rust_str(&driver.batch), rust_str(&driver.policy), rust_str(&driver.claim_label), @@ -1451,41 +1471,45 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); Ok(source) } - fn emit_tail_constants(&self) -> String { + fn emit_tail_constants(&self) -> Result { let mut source = String::new(); - source.push_str(&self.emit_sumcheck_instance_result_constants()); + source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); source.push_str(&self.emit_point_slice_constants()); source.push_str(&self.emit_point_concat_constants()); - source.push_str(&self.emit_opening_claim_constants()); + source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_batch_constants()); - source + Ok(source) } - fn emit_sumcheck_instance_result_constants(&self) -> String { + fn emit_sumcheck_instance_result_constants(&self) -> Result { let instances = self .instance_results .iter() .map(|instance| { - format!( + Ok(format!( " Stage2SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},", rust_str(&instance.symbol), rust_str(&instance.source), rust_str(&instance.claim), - rust_str(&instance.relation), + super::plan_tokens::role_relation_kind_expr( + "Stage2", + &self.role, + &instance.relation + )?, instance.index, instance.point_arity, instance.num_rounds, instance.round_offset, rust_str(&instance.point_order), instance.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE2_SUMCHECK_INSTANCE_RESULTS: &[Stage2SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n" - ) + )) } fn emit_sumcheck_eval_constants(&self) -> String { @@ -1577,25 +1601,27 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); source } - fn emit_opening_claim_constants(&self) -> String { + fn emit_opening_claim_constants(&self) -> Result { let claims = self .opening_claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage2OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},", rust_str(&claim.symbol), rust_str(&claim.oracle), rust_str(&claim.domain), claim.point_arity, - rust_str(&claim.claim_kind), + super::plan_tokens::role_claim_kind_expr("Stage2", &self.role, &claim.claim_kind)?, rust_str(&claim.point_source), rust_str(&claim.eval_source) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[\n{claims}\n];\n\n") + Ok(format!( + "pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[\n{claims}\n];\n\n" + )) } fn emit_opening_batch_constants(&self) -> String { @@ -1728,19 +1754,19 @@ where } else { for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage2ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage2Error::MissingValue { symbol: step.symbol, })?; verify_stage2_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "sumcheck_driver" => { + Stage2ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage2Error::MissingProof { driver: step.symbol, })?; verify_stage2_driver(program, driver, proof, ram, &mut store, transcript, &mut artifacts)?; } - _ => { + Stage2ProgramStepKind::TranscriptAbsorbBytes => { return Err(VerifyStage2Error::InvalidProof { driver: step.symbol, reason: "unsupported stage2 program step", @@ -1803,12 +1829,19 @@ where .ok_or(VerifyStage2Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage2Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage2.product_virtual.uniskip" => { + Stage2RelationKind::Stage2ProductVirtualUniskip => { verify_product_virtual_uniskip(program, driver, proof, store, transcript)? } - "jolt.stage2.batched" => verify_batched_stage2(program, driver, proof, ram, store, transcript)?, + Stage2RelationKind::Stage2Batched => { + verify_batched_stage2(program, driver, proof, ram, store, transcript)? + } relation => return Err(VerifyStage2Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); @@ -1987,15 +2020,15 @@ impl Stage2ValueStore { output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), - _ => { - return Err(VerifyStage2Error::InvalidProof { - driver: output.driver, - reason: "unsupported point order", - }); - } + "as_is" => {} + "reverse" => point.reverse(), + _ => { + return Err(VerifyStage2Error::InvalidProof { + driver: output.driver, + reason: "unsupported point order", + }); } + } Ok(point) }, |input, expected, actual| VerifyStage2Error::InvalidInputLength { @@ -2055,7 +2088,8 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, ) -> Result<(), VerifyStage2Error> { self.0 - .evaluate_available_field_exprs(program.field_exprs, evaluate_stage2_field_expr) + .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .map_err(VerifyStage2Error::from) } fn scalar(&self, symbol: &'static str) -> Result { @@ -2073,109 +2107,6 @@ impl Stage2ValueStore { } } -fn evaluate_stage2_field_expr( - expr: &Stage2FieldExprPlan, - operands: &[F], -) -> Result { - match expr.formula { - "opening_eval" => Ok(single_operand(expr.symbol, operands)?), - "jolt_stage2_product_virtual_uniskip_input" => { - require_operand_count(expr.symbol, 4, operands.len())?; - let weights = lagrange_evals( - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START, - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE, - operands[0], - ); - Ok(weights[0] * operands[1] + weights[1] * operands[2] + weights[2] * operands[3]) - } - "jolt_stage2_ram_read_write_input" => { - require_operand_count(expr.symbol, 3, operands.len())?; - Ok(operands[1] + operands[0] * operands[2]) - } - "jolt_stage2_instruction_lookup_input" => { - require_operand_count(expr.symbol, 6, operands.len())?; - let gamma = operands[0]; - let gamma2 = gamma.square(); - let gamma3 = gamma2 * gamma; - let gamma4 = gamma2.square(); - Ok(operands[1] - + gamma * operands[2] - + gamma2 * operands[3] - + gamma3 * operands[4] - + gamma4 * operands[5]) - } - "field.add" => { - require_operand_count(expr.symbol, 2, operands.len())?; - Ok(operands[0] + operands[1]) - } - "field.sub" => { - require_operand_count(expr.symbol, 2, operands.len())?; - Ok(operands[0] - operands[1]) - } - "field.mul" => { - require_operand_count(expr.symbol, 2, operands.len())?; - Ok(operands[0] * operands[1]) - } - "field.neg" => { - require_operand_count(expr.symbol, 1, operands.len())?; - Ok(-operands[0]) - } - formula => { - if let Some(exponent) = formula.strip_prefix("field.pow:") { - require_operand_count(expr.symbol, 1, operands.len())?; - let exponent = exponent.parse::().map_err(|_| { - VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - } - })?; - return Ok(pow_field(operands[0], exponent)); - } - if let Some(spec) = formula.strip_prefix("poly.lagrange_basis_eval:") { - require_operand_count(expr.symbol, 1, operands.len())?; - let parts = spec.split(':').collect::>(); - if parts.len() != 3 { - return Err(VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - }); - } - let domain_start = parts[0].parse::().map_err(|_| { - VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - } - })?; - let domain_size = parts[1].parse::().map_err(|_| { - VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - } - })?; - let index = parts[2].parse::().map_err(|_| { - VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - } - })?; - let weights = lagrange_evals(domain_start, domain_size, operands[0]); - return weights - .get(index) - .copied() - .ok_or(VerifyStage2Error::InvalidInputLength { - input: expr.symbol, - expected: index + 1, - actual: weights.len(), - }); - } - Err(VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - }) - } - } -} - fn expected_batched_output_claim( program: &'static Stage2VerifierProgramPlan, driver: &'static Stage2SumcheckDriverPlan, @@ -2205,15 +2136,19 @@ fn expected_batched_output_claim( actual: point.len(), })?; let value = match instance.relation { - "jolt.stage2.ram.read_write" => expected_ram_read_write(store, evals, local_point)?, - "jolt.stage2.product_virtual.remainder" => { + Stage2RelationKind::Stage2RamReadWrite => { + expected_ram_read_write(store, evals, local_point)? + } + Stage2RelationKind::Stage2ProductVirtualRemainder => { expected_product_remainder(store, evals, local_point)? } - "jolt.stage2.instruction_lookup.claim_reduction" => { + Stage2RelationKind::Stage2InstructionLookupClaimReduction => { expected_instruction_lookup(store, evals, local_point)? } - "jolt.stage2.ram.raf_evaluation" => expected_ram_raf(evals, local_point, ram)?, - "jolt.stage2.ram.output_check" => expected_ram_output(store, evals, local_point, ram)?, + Stage2RelationKind::Stage2RamRafEvaluation => expected_ram_raf(evals, local_point, ram)?, + Stage2RelationKind::Stage2RamOutputCheck => { + expected_ram_output(store, evals, local_point, ram)? + } relation => return Err(VerifyStage2Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; @@ -2521,10 +2456,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String { fn emit_usize_array(name: &str, values: &[usize]) -> String { let entries = values .iter() - .map(|value| format!(" {value},")) + .map(usize::to_string) .collect::>() - .join("\n"); - format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n") + .join(", "); + format!("pub const {name}: &[usize] = &[{entries}];\n\n") } fn intern_str_array( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 936557f08a..66e09478b9 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -973,14 +973,19 @@ pub type Stage3OpeningInputValue = super::common::StageOpeningInputValue; pub type Stage3VerifierProgramPlan = super::common::StageVerifierProgramPlan; pub use super::common::{ - FieldConstantPlan as Stage3FieldConstantPlan, FieldExprPlan as Stage3FieldExprPlan, + ClaimKind as Stage3ClaimKind, RelationKind as Stage3RelationKind, FieldConstantPlan as Stage3FieldConstantPlan, + FieldExprKind as Stage3FieldExprKind, + FieldExprPlan as Stage3FieldExprPlan, OpeningBatchPlan as Stage3OpeningBatchPlan, OpeningClaimEqualityPlan as Stage3OpeningClaimEqualityPlan, OpeningClaimPlan as Stage3OpeningClaimPlan, OpeningInputPlan as Stage3OpeningInputPlan, PointConcatPlan as Stage3PointConcatPlan, PointSlicePlan as Stage3PointSlicePlan, - ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, + OpeningEqualityMode as Stage3OpeningEqualityMode, + ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, + StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage3SumcheckInstanceResultPlan, + TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, SumcheckClaimPlan as Stage3SumcheckClaimPlan, SumcheckDriverPlan as Stage3SumcheckDriverPlan, @@ -995,8 +1000,7 @@ pub enum VerifyStage3Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage3RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } @@ -1005,12 +1009,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_prover_constants(&self) -> Result { - let mut source = self.emit_shared_constants(); + let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_kernel_constants()); source.push_str(&self.emit_prover_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_prover_sumcheck_driver_constants()?); - source.push_str(&self.emit_tail_constants()); + source.push_str(&self.emit_tail_constants()?); source.push_str( "pub const STAGE3_PROGRAM: Stage3CpuProgramPlan = Stage3CpuProgramPlan {\n\ \x20 params: STAGE3_PARAMS,\n\ @@ -1036,11 +1040,11 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_verifier_constants(&self) -> Result { - let mut source = self.emit_shared_constants(); + let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_verifier_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_verifier_sumcheck_driver_constants()?); - source.push_str(&self.emit_tail_constants()); + source.push_str(&self.emit_tail_constants()?); source.push_str( "pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan {\n\ \x20 params: STAGE3_PARAMS,\n\ @@ -1064,71 +1068,75 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); Ok(source) } - fn emit_shared_constants(&self) -> String { + fn emit_shared_constants(&self) -> Result { let mut source = String::new(); push_format( &mut source, format_args!( - "pub const STAGE3_PARAMS: Stage3Params = Stage3Params {{\n\ - \x20 field: {},\n\ - \x20 pcs: {},\n\ - \x20 transcript: {},\n\ - }};\n", + "pub const STAGE3_PARAMS: Stage3Params = Stage3Params {{ field: {}, pcs: {}, transcript: {} }};\n", rust_str(&self.params.field), rust_str(&self.params.pcs), rust_str(&self.params.transcript) ), ); - source.push_str(&self.emit_program_step_constants()); - source.push_str(&self.emit_transcript_squeeze_constants()); - source.push_str(&self.emit_opening_input_constants()); + source.push_str(&self.emit_program_step_constants()?); + source.push_str(&self.emit_transcript_squeeze_constants()?); + source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); - source.push_str(&self.emit_field_expr_constants()); - source + source.push_str(&self.emit_field_expr_constants()?); + Ok(source) } - fn emit_program_step_constants(&self) -> String { + fn emit_program_step_constants(&self) -> Result { let steps = self .steps .iter() .map(|step| { - format!( + Ok(format!( " Stage3ProgramStepPlan {{ kind: {}, symbol: {} }},", - rust_str(&step.kind), + super::plan_tokens::role_program_step_kind_expr( + "Stage3", &self.role, &step.kind + )?, rust_str(&step.symbol), - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[\n{steps}\n];\n\n") + Ok(format!( + "pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[\n{steps}\n];\n\n" + )) } - fn emit_transcript_squeeze_constants(&self) -> String { + fn emit_transcript_squeeze_constants(&self) -> Result { let squeezes = self .transcript_squeezes .iter() .map(|squeeze| { - format!( + Ok(format!( " Stage3TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},", rust_str(&squeeze.symbol), rust_str(&squeeze.label), - rust_str(&squeeze.kind), + super::plan_tokens::role_transcript_squeeze_kind_expr( + "Stage3", + &self.role, + &squeeze.kind + )?, squeeze.count, - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE3_TRANSCRIPT_SQUEEZES: &[Stage3TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n" - ) + )) } - fn emit_opening_input_constants(&self) -> String { + fn emit_opening_input_constants(&self) -> Result { let inputs = self .opening_inputs .iter() .map(|input| { - format!( + Ok(format!( " Stage3OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},", rust_str(&input.symbol), rust_str(&input.source_stage), @@ -1136,12 +1144,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); rust_str(&input.oracle), rust_str(&input.domain), input.point_arity, - rust_str(&input.claim_kind) - ) + super::plan_tokens::role_claim_kind_expr("Stage3", &self.role, &input.claim_kind)? + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE3_OPENING_INPUTS: &[Stage3OpeningInputPlan] = &[\n{inputs}\n];\n\n") + Ok(format!( + "pub const STAGE3_OPENING_INPUTS: &[Stage3OpeningInputPlan] = &[\n{inputs}\n];\n\n" + )) } fn emit_field_constant_constants(&self) -> String { @@ -1163,25 +1173,28 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); ) } - fn emit_field_expr_constants(&self) -> String { + fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { let exprs = self .field_exprs .iter() .map(|expr| { - format!( - " Stage3FieldExprPlan {{ symbol: {}, kind: {}, formula: {}, operands: {} }},", + Ok(format!( + " Stage3FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", rust_str(&expr.symbol), - rust_str(&expr.kind), - rust_str(&expr.formula), + super::plan_tokens::role_field_expr_kind_expr( + "Stage3", + &self.role, + &expr.formula + )?, rust_str(&expr.operands.join("|")) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - return format!( + return Ok(format!( "pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[\n{exprs}\n];\n" - ); + )); } let mut source = String::new(); @@ -1223,7 +1236,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); "pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[\n{exprs}\n];\n" ), ); - source + Ok(source) } fn emit_kernel_constants(&self) -> String { @@ -1293,7 +1306,11 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); claim.num_rounds, claim.degree, rust_str(&claim.claim), - rust_str(relation), + super::plan_tokens::role_relation_kind_expr( + "Stage3", + &self.role, + relation + )?, rust_str(&claim.claim_value), rust_str(&claim.input_openings.join("|")) )); @@ -1434,7 +1451,11 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); rust_str(&driver.symbol), rust_str(&driver.stage), rust_str(&driver.proof_slot), - rust_str(relation), + super::plan_tokens::role_relation_kind_expr( + "Stage3", + &self.role, + relation + )?, rust_str(&driver.batch), rust_str(&driver.policy), rust_str(&driver.claim_label), @@ -1454,42 +1475,46 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); Ok(source) } - fn emit_tail_constants(&self) -> String { + fn emit_tail_constants(&self) -> Result { let mut source = String::new(); - source.push_str(&self.emit_sumcheck_instance_result_constants()); + source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); source.push_str(&self.emit_point_slice_constants()); source.push_str(&self.emit_point_concat_constants()); - source.push_str(&self.emit_opening_claim_constants()); - source.push_str(&self.emit_opening_claim_equality_constants()); + source.push_str(&self.emit_opening_claim_constants()?); + source.push_str(&self.emit_opening_claim_equality_constants()?); source.push_str(&self.emit_opening_batch_constants()); - source + Ok(source) } - fn emit_sumcheck_instance_result_constants(&self) -> String { + fn emit_sumcheck_instance_result_constants(&self) -> Result { let instances = self .instance_results .iter() .map(|instance| { - format!( + Ok(format!( " Stage3SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},", rust_str(&instance.symbol), rust_str(&instance.source), rust_str(&instance.claim), - rust_str(&instance.relation), + super::plan_tokens::role_relation_kind_expr( + "Stage3", + &self.role, + &instance.relation + )?, instance.index, instance.point_arity, instance.num_rounds, instance.round_offset, rust_str(&instance.point_order), instance.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE3_SUMCHECK_INSTANCE_RESULTS: &[Stage3SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n" - ) + )) } fn emit_sumcheck_eval_constants(&self) -> String { @@ -1581,45 +1606,51 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); source } - fn emit_opening_claim_constants(&self) -> String { + fn emit_opening_claim_constants(&self) -> Result { let claims = self .opening_claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage3OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},", rust_str(&claim.symbol), rust_str(&claim.oracle), rust_str(&claim.domain), claim.point_arity, - rust_str(&claim.claim_kind), + super::plan_tokens::role_claim_kind_expr("Stage3", &self.role, &claim.claim_kind)?, rust_str(&claim.point_source), rust_str(&claim.eval_source) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE3_OPENING_CLAIMS: &[Stage3OpeningClaimPlan] = &[\n{claims}\n];\n\n") + Ok(format!( + "pub const STAGE3_OPENING_CLAIMS: &[Stage3OpeningClaimPlan] = &[\n{claims}\n];\n\n" + )) } - fn emit_opening_claim_equality_constants(&self) -> String { + fn emit_opening_claim_equality_constants(&self) -> Result { let equalities = self .opening_equalities .iter() .map(|equality| { - format!( + Ok(format!( " Stage3OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},", rust_str(&equality.symbol), - rust_str(&equality.mode), + super::plan_tokens::role_opening_equality_mode_expr( + "Stage3", + &self.role, + &equality.mode + )?, rust_str(&equality.lhs), rust_str(&equality.rhs) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE3_OPENING_EQUALITIES: &[Stage3OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n" - ) + )) } fn emit_opening_batch_constants(&self) -> String { @@ -1740,21 +1771,21 @@ where let mut artifacts = Stage3ExecutionArtifacts::default(); for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage3ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage3Error::MissingValue { symbol: step.symbol, })?; verify_stage3_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "sumcheck_driver" => { + Stage3ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage3Error::MissingProof { driver: step.symbol, })?; verify_stage3_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?; } - _ => { + Stage3ProgramStepKind::TranscriptAbsorbBytes => { return Err(VerifyStage3Error::InvalidProof { driver: step.symbol, reason: "unsupported stage3 program step", @@ -1817,16 +1848,17 @@ where .ok_or(VerifyStage3Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage3Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage3.batched" => { + Stage3RelationKind::Stage3Batched => { verify_batched_stage3(program, driver, proof, store, transcript)? } - _ => { - return Err(VerifyStage3Error::UnsupportedRelation { - relation, - }); - } + relation => return Err(VerifyStage3Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); Ok(()) @@ -1937,20 +1969,16 @@ fn expected_batched_output_claim( actual: point.len(), })?; let value = match instance.relation { - "jolt.stage3.spartan_shift" => { + Stage3RelationKind::Stage3SpartanShift => { expected_spartan_shift(store, evals, local_point)? } - "jolt.stage3.instruction_input" => { + Stage3RelationKind::Stage3InstructionInput => { expected_instruction_input(store, evals, local_point)? } - "jolt.stage3.registers_claim_reduction" => { + Stage3RelationKind::Stage3RegistersClaimReduction => { expected_registers(store, evals, local_point)? } - _ => { - return Err(VerifyStage3Error::UnsupportedRelation { - relation: instance.relation, - }); - } + relation => return Err(VerifyStage3Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; } @@ -2064,10 +2092,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String { fn emit_usize_array(name: &str, values: &[usize]) -> String { let entries = values .iter() - .map(|value| format!(" {value},")) + .map(usize::to_string) .collect::>() - .join("\n"); - format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n") + .join(", "); + format!("pub const {name}: &[usize] = &[{entries}];\n\n") } fn intern_str_array( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index b0b5c0ca63..baa507ef5e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -226,7 +226,7 @@ pub fn emit_stage4_rust(module: &BoltModule<'_, Cpu>) -> Result String { + fn emit_source(&self) -> Result { let mut source = String::new(); source.push_str("#![allow(dead_code)]\n\n"); match self.role { @@ -945,10 +945,10 @@ impl Stage4CpuProgram { } } source.push('\n'); - source.push_str(&self.emit_constants()); + source.push_str(&self.emit_constants()?); source.push('\n'); source.push_str(self.emit_entrypoint()); - source + Ok(source) } fn emit_prover_imports() -> &'static str { @@ -1183,11 +1183,15 @@ pub type Stage4Proof = super::common::StageProof; pub type Stage4OpeningInputValue = super::common::StageOpeningInputValue; pub use super::common::{ - FieldConstantPlan as Stage4FieldConstantPlan, FieldExprPlan as Stage4FieldExprPlan, + ClaimKind as Stage4ClaimKind, RelationKind as Stage4RelationKind, FieldConstantPlan as Stage4FieldConstantPlan, + FieldExprKind as Stage4FieldExprKind, + FieldExprPlan as Stage4FieldExprPlan, KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan, OpeningClaimEqualityPlan as Stage4OpeningClaimEqualityPlan, OpeningClaimPlan as Stage4OpeningClaimPlan, OpeningInputPlan as Stage4OpeningInputPlan, + OpeningEqualityMode as Stage4OpeningEqualityMode, PointConcatPlan as Stage4PointConcatPlan, PointSlicePlan as Stage4PointSlicePlan, + ProgramStepKind as Stage4ProgramStepKind, ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, StageProgramPlanNoPointZeros as Stage4CpuProgramPlan, SumcheckBatchPlan as Stage4SumcheckBatchPlan, @@ -1195,6 +1199,7 @@ pub use super::common::{ SumcheckEvalPlan as Stage4SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage4SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan, + TranscriptSqueezeKind as Stage4TranscriptSqueezeKind, TranscriptSqueezePlan as Stage4TranscriptSqueezePlan, }; "# @@ -1216,8 +1221,7 @@ pub enum VerifyStage4Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage4RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } @@ -1227,13 +1231,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); source } - fn emit_constants(&self) -> String { - let mut source = self.emit_shared_constants(); + fn emit_constants(&self) -> Result { + let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_kernel_constants()); - source.push_str(&self.emit_sumcheck_claim_constants()); + source.push_str(&self.emit_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); - source.push_str(&self.emit_sumcheck_driver_constants()); - source.push_str(&self.emit_tail_constants()); + source.push_str(&self.emit_sumcheck_driver_constants()?); + source.push_str(&self.emit_tail_constants()?); push_format( &mut source, format_args!( @@ -1262,67 +1266,67 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); rust_str(self.role_label()) ), ); - source + Ok(source) } - fn emit_shared_constants(&self) -> String { + fn emit_shared_constants(&self) -> Result { let mut source = String::new(); push_format( &mut source, format_args!( - "pub const STAGE4_PARAMS: Stage4Params = Stage4Params {{\n\ - \x20 field: {},\n\ - \x20 pcs: {},\n\ - \x20 transcript: {},\n\ - }};\n", + "pub const STAGE4_PARAMS: Stage4Params = Stage4Params {{ field: {}, pcs: {}, transcript: {} }};\n", rust_str(&self.params.field), rust_str(&self.params.pcs), rust_str(&self.params.transcript) ), ); - source.push_str(&self.emit_program_step_constants()); - source.push_str(&self.emit_transcript_squeeze_constants()); + source.push_str(&self.emit_program_step_constants()?); + source.push_str(&self.emit_transcript_squeeze_constants()?); source.push_str(&self.emit_transcript_absorb_bytes_constants()); - source.push_str(&self.emit_opening_input_constants()); + source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); - source.push_str(&self.emit_field_expr_constants()); - source + source.push_str(&self.emit_field_expr_constants()?); + Ok(source) } - fn emit_program_step_constants(&self) -> String { + fn emit_program_step_constants(&self) -> Result { let steps = self .steps .iter() .map(|step| { - format!( + Ok(format!( " Stage4ProgramStepPlan {{ kind: {}, symbol: {} }},", - rust_str(&step.kind), + super::plan_tokens::role_program_step_kind_expr( + "Stage4", &self.role, &step.kind + )?, rust_str(&step.symbol), - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE4_PROGRAM_STEPS: &[Stage4ProgramStepPlan] = &[\n{steps}\n];\n\n") + Ok(format!( + "pub const STAGE4_PROGRAM_STEPS: &[Stage4ProgramStepPlan] = &[\n{steps}\n];\n\n" + )) } - fn emit_transcript_squeeze_constants(&self) -> String { + fn emit_transcript_squeeze_constants(&self) -> Result { let squeezes = self .transcript_squeezes .iter() .map(|squeeze| { - format!( + Ok(format!( " Stage4TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},", rust_str(&squeeze.symbol), rust_str(&squeeze.label), - rust_str(&squeeze.kind), + super::plan_tokens::role_transcript_squeeze_kind_expr("Stage4", &self.role, &squeeze.kind)?, squeeze.count, - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE4_TRANSCRIPT_SQUEEZES: &[Stage4TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n" - ) + )) } fn emit_transcript_absorb_bytes_constants(&self) -> String { @@ -1344,12 +1348,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); ) } - fn emit_opening_input_constants(&self) -> String { + fn emit_opening_input_constants(&self) -> Result { let inputs = self .opening_inputs .iter() .map(|input| { - format!( + Ok(format!( " Stage4OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},", rust_str(&input.symbol), rust_str(&input.source_stage), @@ -1357,12 +1361,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); rust_str(&input.oracle), rust_str(&input.domain), input.point_arity, - rust_str(&input.claim_kind) - ) + super::plan_tokens::role_claim_kind_expr("Stage4", &self.role, &input.claim_kind)? + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE4_OPENING_INPUTS: &[Stage4OpeningInputPlan] = &[\n{inputs}\n];\n\n") + Ok(format!( + "pub const STAGE4_OPENING_INPUTS: &[Stage4OpeningInputPlan] = &[\n{inputs}\n];\n\n" + )) } fn emit_field_constant_constants(&self) -> String { @@ -1384,25 +1390,28 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); ) } - fn emit_field_expr_constants(&self) -> String { + fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { let exprs = self .field_exprs .iter() .map(|expr| { - format!( - " Stage4FieldExprPlan {{ symbol: {}, kind: {}, formula: {}, operands: {} }},", + Ok(format!( + " Stage4FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", rust_str(&expr.symbol), - rust_str(&expr.kind), - rust_str(&expr.formula), + super::plan_tokens::role_field_expr_kind_expr( + "Stage4", + &self.role, + &expr.formula + )?, rust_str(&expr.operands.join("|")) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - return format!( + return Ok(format!( "pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[\n{exprs}\n];\n" - ); + )); } let mut source = String::new(); @@ -1444,7 +1453,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); "pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[\n{exprs}\n];\n" ), ); - source + Ok(source) } fn emit_kernel_constants(&self) -> String { @@ -1466,13 +1475,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); format!("pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[\n{kernels}\n];\n\n") } - fn emit_sumcheck_claim_constants(&self) -> String { + fn emit_sumcheck_claim_constants(&self) -> Result { if self.role == Role::Verifier { let claims = self .claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage4SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), @@ -1481,16 +1490,20 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); claim.degree, rust_str(&claim.claim), rust_option_str(claim.kernel.as_deref()), - rust_option_str(claim.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage4", + &self.role, + claim.relation.as_deref() + )?, rust_str(&claim.claim_value), rust_str(&claim.input_openings.join("|")) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - return format!( + return Ok(format!( "pub const STAGE4_SUMCHECK_CLAIMS: &[Stage4SumcheckClaimPlan] = &[\n{claims}\n];\n" - ); + )); } let mut source = String::new(); @@ -1505,7 +1518,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); .iter() .enumerate() .map(|(index, claim)| { - format!( + Ok(format!( " Stage4SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: STAGE4_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS }},", rust_str(&claim.symbol), rust_str(&claim.stage), @@ -1514,11 +1527,15 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); claim.degree, rust_str(&claim.claim), rust_option_str(claim.kernel.as_deref()), - rust_option_str(claim.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage4", + &self.role, + claim.relation.as_deref() + )?, rust_str(&claim.claim_value) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); push_format( &mut source, @@ -1526,7 +1543,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); "pub const STAGE4_SUMCHECK_CLAIMS: &[Stage4SumcheckClaimPlan] = &[\n{claims}\n];\n" ), ); - source + Ok(source) } fn emit_sumcheck_batch_constants(&self) -> String { @@ -1609,7 +1626,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); source } - fn emit_sumcheck_driver_constants(&self) -> String { + fn emit_sumcheck_driver_constants(&self) -> Result { let mut source = String::new(); for (index, driver) in self.drivers.iter().enumerate() { source.push_str(&emit_usize_array( @@ -1622,22 +1639,26 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); .iter() .enumerate() .map(|(index, driver)| { - format!( + Ok(format!( " Stage4SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: {}, relation: {}, batch: {}, policy: {}, round_schedule: STAGE4_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},", rust_str(&driver.symbol), rust_str(&driver.stage), rust_str(&driver.proof_slot), rust_option_str(driver.kernel.as_deref()), - rust_option_str(driver.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage4", + &self.role, + driver.relation.as_deref() + )?, rust_str(&driver.batch), rust_str(&driver.policy), rust_str(&driver.claim_label), rust_str(&driver.round_label), driver.num_rounds, driver.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); push_format( &mut source, @@ -1645,45 +1666,49 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); "pub const STAGE4_SUMCHECK_DRIVERS: &[Stage4SumcheckDriverPlan] = &[\n{drivers}\n];\n" ), ); - source + Ok(source) } - fn emit_tail_constants(&self) -> String { + fn emit_tail_constants(&self) -> Result { let mut source = String::new(); - source.push_str(&self.emit_sumcheck_instance_result_constants()); + source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); source.push_str(&self.emit_point_slice_constants()); source.push_str(&self.emit_point_concat_constants()); - source.push_str(&self.emit_opening_claim_constants()); - source.push_str(&self.emit_opening_claim_equality_constants()); + source.push_str(&self.emit_opening_claim_constants()?); + source.push_str(&self.emit_opening_claim_equality_constants()?); source.push_str(&self.emit_opening_batch_constants()); - source + Ok(source) } - fn emit_sumcheck_instance_result_constants(&self) -> String { + fn emit_sumcheck_instance_result_constants(&self) -> Result { let instances = self .instance_results .iter() .map(|instance| { - format!( + Ok(format!( " Stage4SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},", rust_str(&instance.symbol), rust_str(&instance.source), rust_str(&instance.claim), - rust_str(&instance.relation), + super::plan_tokens::role_relation_kind_expr( + "Stage4", + &self.role, + &instance.relation + )?, instance.index, instance.point_arity, instance.num_rounds, instance.round_offset, rust_str(&instance.point_order), instance.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE4_SUMCHECK_INSTANCE_RESULTS: &[Stage4SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n" - ) + )) } fn emit_sumcheck_eval_constants(&self) -> String { @@ -1775,45 +1800,47 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); source } - fn emit_opening_claim_constants(&self) -> String { + fn emit_opening_claim_constants(&self) -> Result { let claims = self .opening_claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage4OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},", rust_str(&claim.symbol), rust_str(&claim.oracle), rust_str(&claim.domain), claim.point_arity, - rust_str(&claim.claim_kind), + super::plan_tokens::role_claim_kind_expr("Stage4", &self.role, &claim.claim_kind)?, rust_str(&claim.point_source), rust_str(&claim.eval_source) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE4_OPENING_CLAIMS: &[Stage4OpeningClaimPlan] = &[\n{claims}\n];\n\n") + Ok(format!( + "pub const STAGE4_OPENING_CLAIMS: &[Stage4OpeningClaimPlan] = &[\n{claims}\n];\n\n" + )) } - fn emit_opening_claim_equality_constants(&self) -> String { + fn emit_opening_claim_equality_constants(&self) -> Result { let equalities = self .opening_equalities .iter() .map(|equality| { - format!( + Ok(format!( " Stage4OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},", rust_str(&equality.symbol), - rust_str(&equality.mode), + super::plan_tokens::role_opening_equality_mode_expr("Stage4", &self.role, &equality.mode)?, rust_str(&equality.lhs), rust_str(&equality.rhs) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE4_OPENING_EQUALITIES: &[Stage4OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n" - ) + )) } fn emit_opening_batch_constants(&self) -> String { @@ -1935,14 +1962,14 @@ where let mut artifacts = Stage4ExecutionArtifacts::default(); for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage4ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage4Error::MissingValue { symbol: step.symbol, })?; verify_stage4_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "transcript_absorb_bytes" => { + Stage4ProgramStepKind::TranscriptAbsorbBytes => { let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or( VerifyStage4Error::MissingValue { symbol: step.symbol, @@ -1950,19 +1977,13 @@ where )?; absorb_stage4_bytes(absorb, transcript); } - "sumcheck_driver" => { + Stage4ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage4Error::MissingProof { driver: step.symbol, })?; verify_stage4_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?; } - _ => { - return Err(VerifyStage4Error::InvalidProof { - driver: step.symbol, - reason: "unsupported stage4 program step", - }); - } } } artifacts @@ -2031,12 +2052,17 @@ where .ok_or(VerifyStage4Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage4Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage4.batched" => { + Stage4RelationKind::Stage4Batched => { verify_batched_stage4(program, driver, proof, store, transcript)? } - _ => return Err(VerifyStage4Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage4Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); Ok(()) @@ -2149,15 +2175,20 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let relation = claim.relation.unwrap_or(""); + let Some(relation) = claim.relation else { + return Err(VerifyStage4Error::InvalidProof { + driver: driver.symbol, + reason: "missing claim relation", + }); + }; let value = match relation { - "jolt.stage4.registers_read_write" => { + Stage4RelationKind::Stage4RegistersReadWrite => { expected_registers_read_write(store, evals, local_point)? } - "jolt.stage4.ram_val_check" => { + Stage4RelationKind::Stage4RamValCheck => { expected_ram_val_check(store, evals, local_point)? } - _ => return Err(VerifyStage4Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage4Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; } @@ -2320,10 +2351,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String { fn emit_usize_array(name: &str, values: &[usize]) -> String { let entries = values .iter() - .map(|value| format!(" {value},")) + .map(usize::to_string) .collect::>() - .join("\n"); - format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n") + .join(", "); + format!("pub const {name}: &[usize] = &[{entries}];\n\n") } fn intern_str_array( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 08e3ebf5c5..0ca24dc9ec 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -226,7 +226,7 @@ pub fn emit_stage5_rust(module: &BoltModule<'_, Cpu>) -> Result String { + fn emit_source(&self) -> Result { let mut source = String::new(); source.push_str("#![allow(dead_code)]\n\n"); match self.role { @@ -946,10 +946,10 @@ impl Stage5CpuProgram { } } source.push('\n'); - source.push_str(&self.emit_constants()); + source.push_str(&self.emit_constants()?); source.push('\n'); source.push_str(self.emit_entrypoint()); - source + Ok(source) } fn emit_prover_imports() -> &'static str { @@ -1185,11 +1185,15 @@ pub type Stage5Proof = super::common::StageProof; pub type Stage5OpeningInputValue = super::common::StageOpeningInputValue; pub use super::common::{ - FieldConstantPlan as Stage5FieldConstantPlan, FieldExprPlan as Stage5FieldExprPlan, + ClaimKind as Stage5ClaimKind, RelationKind as Stage5RelationKind, FieldConstantPlan as Stage5FieldConstantPlan, + FieldExprKind as Stage5FieldExprKind, + FieldExprPlan as Stage5FieldExprPlan, KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan, OpeningClaimEqualityPlan as Stage5OpeningClaimEqualityPlan, OpeningClaimPlan as Stage5OpeningClaimPlan, OpeningInputPlan as Stage5OpeningInputPlan, + OpeningEqualityMode as Stage5OpeningEqualityMode, PointConcatPlan as Stage5PointConcatPlan, PointSlicePlan as Stage5PointSlicePlan, + ProgramStepKind as Stage5ProgramStepKind, ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params, StageProgramPlanNoPointZeros as Stage5CpuProgramPlan, SumcheckBatchPlan as Stage5SumcheckBatchPlan, @@ -1197,6 +1201,7 @@ pub use super::common::{ SumcheckEvalPlan as Stage5SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage5SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage5TranscriptAbsorbBytesPlan, + TranscriptSqueezeKind as Stage5TranscriptSqueezeKind, TranscriptSqueezePlan as Stage5TranscriptSqueezePlan, }; "# @@ -1218,8 +1223,7 @@ pub enum VerifyStage5Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage5RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } @@ -1229,13 +1233,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); source } - fn emit_constants(&self) -> String { - let mut source = self.emit_shared_constants(); + fn emit_constants(&self) -> Result { + let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_kernel_constants()); - source.push_str(&self.emit_sumcheck_claim_constants()); + source.push_str(&self.emit_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); - source.push_str(&self.emit_sumcheck_driver_constants()); - source.push_str(&self.emit_tail_constants()); + source.push_str(&self.emit_sumcheck_driver_constants()?); + source.push_str(&self.emit_tail_constants()?); push_format( &mut source, format_args!( @@ -1264,67 +1268,67 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); rust_str(self.role_label()) ), ); - source + Ok(source) } - fn emit_shared_constants(&self) -> String { + fn emit_shared_constants(&self) -> Result { let mut source = String::new(); push_format( &mut source, format_args!( - "pub const STAGE5_PARAMS: Stage5Params = Stage5Params {{\n\ - \x20 field: {},\n\ - \x20 pcs: {},\n\ - \x20 transcript: {},\n\ - }};\n", + "pub const STAGE5_PARAMS: Stage5Params = Stage5Params {{ field: {}, pcs: {}, transcript: {} }};\n", rust_str(&self.params.field), rust_str(&self.params.pcs), rust_str(&self.params.transcript) ), ); - source.push_str(&self.emit_program_step_constants()); - source.push_str(&self.emit_transcript_squeeze_constants()); + source.push_str(&self.emit_program_step_constants()?); + source.push_str(&self.emit_transcript_squeeze_constants()?); source.push_str(&self.emit_transcript_absorb_bytes_constants()); - source.push_str(&self.emit_opening_input_constants()); + source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); - source.push_str(&self.emit_field_expr_constants()); - source + source.push_str(&self.emit_field_expr_constants()?); + Ok(source) } - fn emit_program_step_constants(&self) -> String { + fn emit_program_step_constants(&self) -> Result { let steps = self .steps .iter() .map(|step| { - format!( + Ok(format!( " Stage5ProgramStepPlan {{ kind: {}, symbol: {} }},", - rust_str(&step.kind), + super::plan_tokens::role_program_step_kind_expr( + "Stage5", &self.role, &step.kind + )?, rust_str(&step.symbol), - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE5_PROGRAM_STEPS: &[Stage5ProgramStepPlan] = &[\n{steps}\n];\n\n") + Ok(format!( + "pub const STAGE5_PROGRAM_STEPS: &[Stage5ProgramStepPlan] = &[\n{steps}\n];\n\n" + )) } - fn emit_transcript_squeeze_constants(&self) -> String { + fn emit_transcript_squeeze_constants(&self) -> Result { let squeezes = self .transcript_squeezes .iter() .map(|squeeze| { - format!( + Ok(format!( " Stage5TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},", rust_str(&squeeze.symbol), rust_str(&squeeze.label), - rust_str(&squeeze.kind), + super::plan_tokens::role_transcript_squeeze_kind_expr("Stage5", &self.role, &squeeze.kind)?, squeeze.count, - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE5_TRANSCRIPT_SQUEEZES: &[Stage5TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n" - ) + )) } fn emit_transcript_absorb_bytes_constants(&self) -> String { @@ -1346,12 +1350,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); ) } - fn emit_opening_input_constants(&self) -> String { + fn emit_opening_input_constants(&self) -> Result { let inputs = self .opening_inputs .iter() .map(|input| { - format!( + Ok(format!( " Stage5OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},", rust_str(&input.symbol), rust_str(&input.source_stage), @@ -1359,12 +1363,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); rust_str(&input.oracle), rust_str(&input.domain), input.point_arity, - rust_str(&input.claim_kind) - ) + super::plan_tokens::role_claim_kind_expr("Stage5", &self.role, &input.claim_kind)? + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE5_OPENING_INPUTS: &[Stage5OpeningInputPlan] = &[\n{inputs}\n];\n\n") + Ok(format!( + "pub const STAGE5_OPENING_INPUTS: &[Stage5OpeningInputPlan] = &[\n{inputs}\n];\n\n" + )) } fn emit_field_constant_constants(&self) -> String { @@ -1386,25 +1392,28 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); ) } - fn emit_field_expr_constants(&self) -> String { + fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { let exprs = self .field_exprs .iter() .map(|expr| { - format!( - " Stage5FieldExprPlan {{ symbol: {}, kind: {}, formula: {}, operands: {} }},", + Ok(format!( + " Stage5FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", rust_str(&expr.symbol), - rust_str(&expr.kind), - rust_str(&expr.formula), + super::plan_tokens::role_field_expr_kind_expr( + "Stage5", + &self.role, + &expr.formula + )?, rust_str(&expr.operands.join("|")) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - return format!( + return Ok(format!( "pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[\n{exprs}\n];\n" - ); + )); } let mut source = String::new(); @@ -1446,7 +1455,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); "pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[\n{exprs}\n];\n" ), ); - source + Ok(source) } fn emit_kernel_constants(&self) -> String { @@ -1468,13 +1477,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); format!("pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[\n{kernels}\n];\n\n") } - fn emit_sumcheck_claim_constants(&self) -> String { + fn emit_sumcheck_claim_constants(&self) -> Result { if self.role == Role::Verifier { let claims = self .claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage5SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), @@ -1483,16 +1492,20 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); claim.degree, rust_str(&claim.claim), rust_option_str(claim.kernel.as_deref()), - rust_option_str(claim.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage5", + &self.role, + claim.relation.as_deref() + )?, rust_str(&claim.claim_value), rust_str(&claim.input_openings.join("|")) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - return format!( + return Ok(format!( "pub const STAGE5_SUMCHECK_CLAIMS: &[Stage5SumcheckClaimPlan] = &[\n{claims}\n];\n" - ); + )); } let mut source = String::new(); @@ -1507,7 +1520,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); .iter() .enumerate() .map(|(index, claim)| { - format!( + Ok(format!( " Stage5SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: STAGE5_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS }},", rust_str(&claim.symbol), rust_str(&claim.stage), @@ -1516,11 +1529,15 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); claim.degree, rust_str(&claim.claim), rust_option_str(claim.kernel.as_deref()), - rust_option_str(claim.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage5", + &self.role, + claim.relation.as_deref() + )?, rust_str(&claim.claim_value) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); push_format( &mut source, @@ -1528,7 +1545,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); "pub const STAGE5_SUMCHECK_CLAIMS: &[Stage5SumcheckClaimPlan] = &[\n{claims}\n];\n" ), ); - source + Ok(source) } fn emit_sumcheck_batch_constants(&self) -> String { @@ -1611,7 +1628,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); source } - fn emit_sumcheck_driver_constants(&self) -> String { + fn emit_sumcheck_driver_constants(&self) -> Result { let mut source = String::new(); for (index, driver) in self.drivers.iter().enumerate() { source.push_str(&emit_usize_array( @@ -1624,22 +1641,26 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); .iter() .enumerate() .map(|(index, driver)| { - format!( + Ok(format!( " Stage5SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: {}, relation: {}, batch: {}, policy: {}, round_schedule: STAGE5_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},", rust_str(&driver.symbol), rust_str(&driver.stage), rust_str(&driver.proof_slot), rust_option_str(driver.kernel.as_deref()), - rust_option_str(driver.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage5", + &self.role, + driver.relation.as_deref() + )?, rust_str(&driver.batch), rust_str(&driver.policy), rust_str(&driver.claim_label), rust_str(&driver.round_label), driver.num_rounds, driver.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); push_format( &mut source, @@ -1647,45 +1668,49 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); "pub const STAGE5_SUMCHECK_DRIVERS: &[Stage5SumcheckDriverPlan] = &[\n{drivers}\n];\n" ), ); - source + Ok(source) } - fn emit_tail_constants(&self) -> String { + fn emit_tail_constants(&self) -> Result { let mut source = String::new(); - source.push_str(&self.emit_sumcheck_instance_result_constants()); + source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); source.push_str(&self.emit_point_slice_constants()); source.push_str(&self.emit_point_concat_constants()); - source.push_str(&self.emit_opening_claim_constants()); - source.push_str(&self.emit_opening_claim_equality_constants()); + source.push_str(&self.emit_opening_claim_constants()?); + source.push_str(&self.emit_opening_claim_equality_constants()?); source.push_str(&self.emit_opening_batch_constants()); - source + Ok(source) } - fn emit_sumcheck_instance_result_constants(&self) -> String { + fn emit_sumcheck_instance_result_constants(&self) -> Result { let instances = self .instance_results .iter() .map(|instance| { - format!( + Ok(format!( " Stage5SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},", rust_str(&instance.symbol), rust_str(&instance.source), rust_str(&instance.claim), - rust_str(&instance.relation), + super::plan_tokens::role_relation_kind_expr( + "Stage5", + &self.role, + &instance.relation + )?, instance.index, instance.point_arity, instance.num_rounds, instance.round_offset, rust_str(&instance.point_order), instance.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE5_SUMCHECK_INSTANCE_RESULTS: &[Stage5SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n" - ) + )) } fn emit_sumcheck_eval_constants(&self) -> String { @@ -1777,45 +1802,47 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); source } - fn emit_opening_claim_constants(&self) -> String { + fn emit_opening_claim_constants(&self) -> Result { let claims = self .opening_claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage5OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},", rust_str(&claim.symbol), rust_str(&claim.oracle), rust_str(&claim.domain), claim.point_arity, - rust_str(&claim.claim_kind), + super::plan_tokens::role_claim_kind_expr("Stage5", &self.role, &claim.claim_kind)?, rust_str(&claim.point_source), rust_str(&claim.eval_source) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE5_OPENING_CLAIMS: &[Stage5OpeningClaimPlan] = &[\n{claims}\n];\n\n") + Ok(format!( + "pub const STAGE5_OPENING_CLAIMS: &[Stage5OpeningClaimPlan] = &[\n{claims}\n];\n\n" + )) } - fn emit_opening_claim_equality_constants(&self) -> String { + fn emit_opening_claim_equality_constants(&self) -> Result { let equalities = self .opening_equalities .iter() .map(|equality| { - format!( + Ok(format!( " Stage5OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},", rust_str(&equality.symbol), - rust_str(&equality.mode), + super::plan_tokens::role_opening_equality_mode_expr("Stage5", &self.role, &equality.mode)?, rust_str(&equality.lhs), rust_str(&equality.rhs) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE5_OPENING_EQUALITIES: &[Stage5OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n" - ) + )) } fn emit_opening_batch_constants(&self) -> String { @@ -1937,14 +1964,14 @@ where let mut artifacts = Stage5ExecutionArtifacts::default(); for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage5ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage5Error::MissingValue { symbol: step.symbol, })?; verify_stage5_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "transcript_absorb_bytes" => { + Stage5ProgramStepKind::TranscriptAbsorbBytes => { let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or( VerifyStage5Error::MissingValue { symbol: step.symbol, @@ -1952,19 +1979,13 @@ where )?; absorb_stage5_bytes(absorb, transcript); } - "sumcheck_driver" => { + Stage5ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage5Error::MissingProof { driver: step.symbol, })?; verify_stage5_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?; } - _ => { - return Err(VerifyStage5Error::InvalidProof { - driver: step.symbol, - reason: "unsupported stage5 program step", - }); - } } } artifacts @@ -2033,12 +2054,17 @@ where .ok_or(VerifyStage5Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage5Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage5.batched" => { + Stage5RelationKind::Stage5Batched => { verify_batched_stage5(program, driver, proof, store, transcript)? } - _ => return Err(VerifyStage5Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); Ok(()) @@ -2151,18 +2177,23 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let relation = claim.relation.unwrap_or(""); + let Some(relation) = claim.relation else { + return Err(VerifyStage5Error::InvalidProof { + driver: driver.symbol, + reason: "missing claim relation", + }); + }; let value = match relation { - "jolt.stage5.instruction_read_raf" => { + Stage5RelationKind::Stage5InstructionReadRaf => { expected_instruction_read_raf(store, evals, local_point)? } - "jolt.stage5.ram_ra_claim_reduction" => { + Stage5RelationKind::Stage5RamRaClaimReduction => { expected_ram_ra_claim_reduction(store, evals, local_point)? } - "jolt.stage5.registers_val_evaluation" => { + Stage5RelationKind::Stage5RegistersValEvaluation => { expected_registers_val_evaluation(store, evals, local_point)? } - _ => return Err(VerifyStage5Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; } @@ -2322,10 +2353,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String { fn emit_usize_array(name: &str, values: &[usize]) -> String { let entries = values .iter() - .map(|value| format!(" {value},")) + .map(usize::to_string) .collect::>() - .join("\n"); - format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n") + .join(", "); + format!("pub const {name}: &[usize] = &[{entries}];\n\n") } fn intern_str_array( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 191bee1f2c..132cd5310d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -234,7 +234,7 @@ pub fn emit_stage6_rust(module: &BoltModule<'_, Cpu>) -> Result String { + fn emit_source(&self) -> Result { let mut source = String::new(); source.push_str("#![allow(dead_code)]\n\n"); match self.role { @@ -970,10 +970,10 @@ impl Stage6CpuProgram { } } source.push('\n'); - source.push_str(&self.emit_constants()); + source.push_str(&self.emit_constants()?); source.push('\n'); source.push_str(self.emit_entrypoint()); - source + Ok(source) } fn emit_prover_imports() -> &'static str { @@ -1215,18 +1215,23 @@ pub type Stage6Proof = super::common::StageProof; pub type Stage6OpeningInputValue = super::common::StageOpeningInputValue; pub use super::common::{ - FieldConstantPlan as Stage6FieldConstantPlan, FieldExprPlan as Stage6FieldExprPlan, + ClaimKind as Stage6ClaimKind, RelationKind as Stage6RelationKind, FieldConstantPlan as Stage6FieldConstantPlan, + FieldExprKind as Stage6FieldExprKind, + FieldExprPlan as Stage6FieldExprPlan, KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan, OpeningClaimEqualityPlan as Stage6OpeningClaimEqualityPlan, OpeningClaimPlan as Stage6OpeningClaimPlan, OpeningInputPlan as Stage6OpeningInputPlan, + OpeningEqualityMode as Stage6OpeningEqualityMode, PointConcatPlan as Stage6PointConcatPlan, PointSlicePlan as Stage6PointSlicePlan, - PointZeroPlan as Stage6PointZeroPlan, ProgramStepPlan as Stage6ProgramStepPlan, + PointZeroPlan as Stage6PointZeroPlan, ProgramStepKind as Stage6ProgramStepKind, + ProgramStepPlan as Stage6ProgramStepPlan, StageParams as Stage6Params, StageProgramPlan as Stage6CpuProgramPlan, SumcheckBatchPlan as Stage6SumcheckBatchPlan, SumcheckClaimPlan as Stage6SumcheckClaimPlan, SumcheckDriverPlan as Stage6SumcheckDriverPlan, SumcheckEvalPlan as Stage6SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage6SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage6TranscriptAbsorbBytesPlan, + TranscriptSqueezeKind as Stage6TranscriptSqueezeKind, TranscriptSqueezePlan as Stage6TranscriptSqueezePlan, }; "# @@ -1288,7 +1293,6 @@ pub struct Stage6VerifierData { } const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { - hamming_booleanity_relation: "jolt.stage6.hamming_booleanity", hamming_booleanity_instance: "stage6.hamming_booleanity.instance", booleanity_point: "stage6.booleanity.point", stage5_instruction_ra0: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", @@ -1351,8 +1355,7 @@ pub enum VerifyStage6Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage6RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } @@ -1362,13 +1365,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); source } - fn emit_constants(&self) -> String { - let mut source = self.emit_shared_constants(); + fn emit_constants(&self) -> Result { + let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_kernel_constants()); - source.push_str(&self.emit_sumcheck_claim_constants()); + source.push_str(&self.emit_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); - source.push_str(&self.emit_sumcheck_driver_constants()); - source.push_str(&self.emit_tail_constants()); + source.push_str(&self.emit_sumcheck_driver_constants()?); + source.push_str(&self.emit_tail_constants()?); push_format( &mut source, format_args!( @@ -1398,67 +1401,67 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); rust_str(self.role_label()) ), ); - source + Ok(source) } - fn emit_shared_constants(&self) -> String { + fn emit_shared_constants(&self) -> Result { let mut source = String::new(); push_format( &mut source, format_args!( - "pub const STAGE6_PARAMS: Stage6Params = Stage6Params {{\n\ - \x20 field: {},\n\ - \x20 pcs: {},\n\ - \x20 transcript: {},\n\ - }};\n", + "pub const STAGE6_PARAMS: Stage6Params = Stage6Params {{ field: {}, pcs: {}, transcript: {} }};\n", rust_str(&self.params.field), rust_str(&self.params.pcs), rust_str(&self.params.transcript) ), ); - source.push_str(&self.emit_program_step_constants()); - source.push_str(&self.emit_transcript_squeeze_constants()); + source.push_str(&self.emit_program_step_constants()?); + source.push_str(&self.emit_transcript_squeeze_constants()?); source.push_str(&self.emit_transcript_absorb_bytes_constants()); - source.push_str(&self.emit_opening_input_constants()); + source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); - source.push_str(&self.emit_field_expr_constants()); - source + source.push_str(&self.emit_field_expr_constants()?); + Ok(source) } - fn emit_program_step_constants(&self) -> String { + fn emit_program_step_constants(&self) -> Result { let steps = self .steps .iter() .map(|step| { - format!( + Ok(format!( " Stage6ProgramStepPlan {{ kind: {}, symbol: {} }},", - rust_str(&step.kind), + super::plan_tokens::role_program_step_kind_expr( + "Stage6", &self.role, &step.kind + )?, rust_str(&step.symbol), - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE6_PROGRAM_STEPS: &[Stage6ProgramStepPlan] = &[\n{steps}\n];\n\n") + Ok(format!( + "pub const STAGE6_PROGRAM_STEPS: &[Stage6ProgramStepPlan] = &[\n{steps}\n];\n\n" + )) } - fn emit_transcript_squeeze_constants(&self) -> String { + fn emit_transcript_squeeze_constants(&self) -> Result { let squeezes = self .transcript_squeezes .iter() .map(|squeeze| { - format!( + Ok(format!( " Stage6TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},", rust_str(&squeeze.symbol), rust_str(&squeeze.label), - rust_str(&squeeze.kind), + super::plan_tokens::role_transcript_squeeze_kind_expr("Stage6", &self.role, &squeeze.kind)?, squeeze.count, - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE6_TRANSCRIPT_SQUEEZES: &[Stage6TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n" - ) + )) } fn emit_transcript_absorb_bytes_constants(&self) -> String { @@ -1480,12 +1483,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); ) } - fn emit_opening_input_constants(&self) -> String { + fn emit_opening_input_constants(&self) -> Result { let inputs = self .opening_inputs .iter() .map(|input| { - format!( + Ok(format!( " Stage6OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},", rust_str(&input.symbol), rust_str(&input.source_stage), @@ -1493,12 +1496,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); rust_str(&input.oracle), rust_str(&input.domain), input.point_arity, - rust_str(&input.claim_kind) - ) + super::plan_tokens::role_claim_kind_expr("Stage6", &self.role, &input.claim_kind)? + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[\n{inputs}\n];\n\n") + Ok(format!( + "pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[\n{inputs}\n];\n\n" + )) } fn emit_field_constant_constants(&self) -> String { @@ -1520,7 +1525,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); ) } - fn emit_field_expr_constants(&self) -> String { + fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { let rows = self .field_exprs @@ -1529,22 +1534,26 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); let exprs = chunk .iter() .map(|expr| { - format!( + Ok(format!( "stage6_field_expr!({}, {}, {})", rust_str(&expr.symbol), - rust_str(&expr.formula), + super::plan_tokens::role_field_expr_kind_expr( + "Stage6", + &self.role, + &expr.formula + )?, rust_str(&expr.operands.join("|")) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join(", "); - format!(" {exprs},") + Ok(format!(" {exprs},")) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - return format!( - "macro_rules! stage6_field_expr {{\n ($symbol:literal, $formula:literal, $operands:literal) => {{\n Stage6FieldExprPlan {{ symbol: $symbol, kind: \"op\", formula: $formula, operands: $operands }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[\n{rows}\n];\n" - ); + return Ok(format!( + "macro_rules! stage6_field_expr {{\n ($symbol:literal, $kind:expr, $operands:literal) => {{\n Stage6FieldExprPlan {{ symbol: $symbol, kind: $kind, operands: $operands }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[\n{rows}\n];\n" + )); } let mut source = String::new(); @@ -1586,7 +1595,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); "pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[\n{exprs}\n];\n" ), ); - source + Ok(source) } fn emit_kernel_constants(&self) -> String { @@ -1608,13 +1617,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); format!("pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[\n{kernels}\n];\n\n") } - fn emit_sumcheck_claim_constants(&self) -> String { + fn emit_sumcheck_claim_constants(&self) -> Result { if self.role == Role::Verifier { let claims = self .claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage6SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), @@ -1623,16 +1632,20 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); claim.degree, rust_str(&claim.claim), rust_option_str(claim.kernel.as_deref()), - rust_option_str(claim.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage6", + &self.role, + claim.relation.as_deref() + )?, rust_str(&claim.claim_value), rust_str(&claim.input_openings.join("|")) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - return format!( + return Ok(format!( "pub const STAGE6_SUMCHECK_CLAIMS: &[Stage6SumcheckClaimPlan] = &[\n{claims}\n];\n" - ); + )); } let mut source = String::new(); @@ -1647,7 +1660,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); .iter() .enumerate() .map(|(index, claim)| { - format!( + Ok(format!( " Stage6SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: STAGE6_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS }},", rust_str(&claim.symbol), rust_str(&claim.stage), @@ -1656,11 +1669,15 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); claim.degree, rust_str(&claim.claim), rust_option_str(claim.kernel.as_deref()), - rust_option_str(claim.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage6", + &self.role, + claim.relation.as_deref() + )?, rust_str(&claim.claim_value) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); push_format( &mut source, @@ -1668,7 +1685,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); "pub const STAGE6_SUMCHECK_CLAIMS: &[Stage6SumcheckClaimPlan] = &[\n{claims}\n];\n" ), ); - source + Ok(source) } fn emit_sumcheck_batch_constants(&self) -> String { @@ -1751,7 +1768,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); source } - fn emit_sumcheck_driver_constants(&self) -> String { + fn emit_sumcheck_driver_constants(&self) -> Result { let mut source = String::new(); for (index, driver) in self.drivers.iter().enumerate() { source.push_str(&emit_usize_array( @@ -1764,22 +1781,26 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); .iter() .enumerate() .map(|(index, driver)| { - format!( + Ok(format!( " Stage6SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: {}, relation: {}, batch: {}, policy: {}, round_schedule: STAGE6_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},", rust_str(&driver.symbol), rust_str(&driver.stage), rust_str(&driver.proof_slot), rust_option_str(driver.kernel.as_deref()), - rust_option_str(driver.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage6", + &self.role, + driver.relation.as_deref() + )?, rust_str(&driver.batch), rust_str(&driver.policy), rust_str(&driver.claim_label), rust_str(&driver.round_label), driver.num_rounds, driver.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); push_format( &mut source, @@ -1787,46 +1808,50 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); "pub const STAGE6_SUMCHECK_DRIVERS: &[Stage6SumcheckDriverPlan] = &[\n{drivers}\n];\n" ), ); - source + Ok(source) } - fn emit_tail_constants(&self) -> String { + fn emit_tail_constants(&self) -> Result { let mut source = String::new(); - source.push_str(&self.emit_sumcheck_instance_result_constants()); + source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); source.push_str(&self.emit_point_zero_constants()); source.push_str(&self.emit_point_slice_constants()); source.push_str(&self.emit_point_concat_constants()); - source.push_str(&self.emit_opening_claim_constants()); - source.push_str(&self.emit_opening_claim_equality_constants()); + source.push_str(&self.emit_opening_claim_constants()?); + source.push_str(&self.emit_opening_claim_equality_constants()?); source.push_str(&self.emit_opening_batch_constants()); - source + Ok(source) } - fn emit_sumcheck_instance_result_constants(&self) -> String { + fn emit_sumcheck_instance_result_constants(&self) -> Result { let instances = self .instance_results .iter() .map(|instance| { - format!( + Ok(format!( " Stage6SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},", rust_str(&instance.symbol), rust_str(&instance.source), rust_str(&instance.claim), - rust_str(&instance.relation), + super::plan_tokens::role_relation_kind_expr( + "Stage6", + &self.role, + &instance.relation + )?, instance.index, instance.point_arity, instance.num_rounds, instance.round_offset, rust_str(&instance.point_order), instance.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE6_SUMCHECK_INSTANCE_RESULTS: &[Stage6SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n" - ) + )) } fn emit_sumcheck_eval_constants(&self) -> String { @@ -1944,45 +1969,47 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); source } - fn emit_opening_claim_constants(&self) -> String { + fn emit_opening_claim_constants(&self) -> Result { let claims = self .opening_claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage6OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},", rust_str(&claim.symbol), rust_str(&claim.oracle), rust_str(&claim.domain), claim.point_arity, - rust_str(&claim.claim_kind), + super::plan_tokens::role_claim_kind_expr("Stage6", &self.role, &claim.claim_kind)?, rust_str(&claim.point_source), rust_str(&claim.eval_source) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[\n{claims}\n];\n\n") + Ok(format!( + "pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[\n{claims}\n];\n\n" + )) } - fn emit_opening_claim_equality_constants(&self) -> String { + fn emit_opening_claim_equality_constants(&self) -> Result { let equalities = self .opening_equalities .iter() .map(|equality| { - format!( + Ok(format!( " Stage6OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},", rust_str(&equality.symbol), - rust_str(&equality.mode), + super::plan_tokens::role_opening_equality_mode_expr("Stage6", &self.role, &equality.mode)?, rust_str(&equality.lhs), rust_str(&equality.rhs) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE6_OPENING_EQUALITIES: &[Stage6OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n" - ) + )) } fn emit_opening_batch_constants(&self) -> String { @@ -2107,14 +2134,14 @@ where let mut artifacts = Stage6ExecutionArtifacts::default(); for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage6ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage6Error::MissingValue { symbol: step.symbol, })?; verify_stage6_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "transcript_absorb_bytes" => { + Stage6ProgramStepKind::TranscriptAbsorbBytes => { let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or( VerifyStage6Error::MissingValue { symbol: step.symbol, @@ -2122,7 +2149,7 @@ where )?; absorb_stage6_bytes(absorb, transcript); } - "sumcheck_driver" => { + Stage6ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage6Error::MissingProof { driver: step.symbol, @@ -2137,12 +2164,6 @@ where &mut artifacts, )?; } - _ => { - return Err(VerifyStage6Error::InvalidProof { - driver: step.symbol, - reason: "unsupported stage6 program step", - }); - } } } artifacts @@ -2216,12 +2237,17 @@ where .ok_or(VerifyStage6Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage6Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage6.batched" => { + Stage6RelationKind::Stage6Batched => { verify_batched_stage6(program, driver, proof, verifier_data, store, transcript)? } - _ => return Err(VerifyStage6Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); Ok(()) @@ -2344,9 +2370,14 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let relation = claim.relation.unwrap_or(""); + let Some(relation) = claim.relation else { + return Err(VerifyStage6Error::InvalidProof { + driver: driver.symbol, + reason: "missing claim relation", + }); + }; let value = match relation { - "jolt.stage6.bytecode_read_raf" => { + Stage6RelationKind::Stage6BytecodeReadRaf => { let data = verifier_data .and_then(|data| data.bytecode_read_raf.as_ref()) .ok_or(VerifyStage6Error::MissingValue { @@ -2354,22 +2385,22 @@ fn expected_batched_output_claim( })?; expected_bytecode_read_raf(program, data, store, evals, local_point)? } - "jolt.stage6.booleanity" => { + Stage6RelationKind::Stage6Booleanity => { expected_booleanity(program, store, evals, local_point)? } - "jolt.stage6.hamming_booleanity" => { + Stage6RelationKind::Stage6HammingBooleanity => { expected_hamming_booleanity(store, evals, local_point)? } - "jolt.stage6.ram_ra_virtual" => { + Stage6RelationKind::Stage6RamRaVirtual => { expected_ram_ra_virtual(store, evals, local_point)? } - "jolt.stage6.instruction_ra_virtual" => { + Stage6RelationKind::Stage6InstructionRaVirtual => { expected_instruction_ra_virtual(program, store, evals, local_point)? } - "jolt.stage6.inc_claim_reduction" => { + Stage6RelationKind::Stage6IncClaimReduction => { expected_inc_claim_reduction(store, evals, local_point)? } - _ => return Err(VerifyStage6Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; } @@ -2492,10 +2523,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String { fn emit_usize_array(name: &str, values: &[usize]) -> String { let entries = values .iter() - .map(|value| format!(" {value},")) + .map(usize::to_string) .collect::>() - .join("\n"); - format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n") + .join(", "); + format!("pub const {name}: &[usize] = &[{entries}];\n\n") } fn intern_str_array( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 764a0d8ec4..f21dea8200 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -234,7 +234,7 @@ pub fn emit_stage7_rust(module: &BoltModule<'_, Cpu>) -> Result String { + fn emit_source(&self) -> Result { let mut source = String::new(); source.push_str("#![allow(dead_code)]\n\n"); match self.role { @@ -967,10 +967,10 @@ impl Stage7CpuProgram { } } source.push('\n'); - source.push_str(&self.emit_constants()); + source.push_str(&self.emit_constants()?); source.push('\n'); source.push_str(self.emit_entrypoint()); - source + Ok(source) } fn emit_prover_imports() -> &'static str { @@ -984,7 +984,7 @@ impl Stage7CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, reverse_slice};\n\ + "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ use jolt_field::{Field, Fr, RingCore};\n\ use jolt_poly::EqPolynomial;\n\ use jolt_sumcheck::SumcheckError;\n\ @@ -1213,18 +1213,23 @@ pub type Stage7Proof = super::common::StageProof; pub type Stage7OpeningInputValue = super::common::StageOpeningInputValue; pub use super::common::{ - FieldConstantPlan as Stage7FieldConstantPlan, FieldExprPlan as Stage7FieldExprPlan, + ClaimKind as Stage7ClaimKind, RelationKind as Stage7RelationKind, FieldConstantPlan as Stage7FieldConstantPlan, + FieldExprKind as Stage7FieldExprKind, + FieldExprPlan as Stage7FieldExprPlan, KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan, OpeningClaimEqualityPlan as Stage7OpeningClaimEqualityPlan, OpeningClaimPlan as Stage7OpeningClaimPlan, OpeningInputPlan as Stage7OpeningInputPlan, + OpeningEqualityMode as Stage7OpeningEqualityMode, PointConcatPlan as Stage7PointConcatPlan, PointSlicePlan as Stage7PointSlicePlan, - PointZeroPlan as Stage7PointZeroPlan, ProgramStepPlan as Stage7ProgramStepPlan, + PointZeroPlan as Stage7PointZeroPlan, ProgramStepKind as Stage7ProgramStepKind, + ProgramStepPlan as Stage7ProgramStepPlan, StageParams as Stage7Params, StageProgramPlan as Stage7CpuProgramPlan, SumcheckBatchPlan as Stage7SumcheckBatchPlan, SumcheckClaimPlan as Stage7SumcheckClaimPlan, SumcheckDriverPlan as Stage7SumcheckDriverPlan, SumcheckEvalPlan as Stage7SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage7SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage7TranscriptAbsorbBytesPlan, + TranscriptSqueezeKind as Stage7TranscriptSqueezeKind, TranscriptSqueezePlan as Stage7TranscriptSqueezePlan, }; "# @@ -1246,8 +1251,7 @@ pub enum VerifyStage7Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage7RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } @@ -1257,13 +1261,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); source } - fn emit_constants(&self) -> String { - let mut source = self.emit_shared_constants(); + fn emit_constants(&self) -> Result { + let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_kernel_constants()); - source.push_str(&self.emit_sumcheck_claim_constants()); + source.push_str(&self.emit_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); - source.push_str(&self.emit_sumcheck_driver_constants()); - source.push_str(&self.emit_tail_constants()); + source.push_str(&self.emit_sumcheck_driver_constants()?); + source.push_str(&self.emit_tail_constants()?); push_format( &mut source, format_args!( @@ -1293,67 +1297,67 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); rust_str(self.role_label()) ), ); - source + Ok(source) } - fn emit_shared_constants(&self) -> String { + fn emit_shared_constants(&self) -> Result { let mut source = String::new(); push_format( &mut source, format_args!( - "pub const STAGE7_PARAMS: Stage7Params = Stage7Params {{\n\ - \x20 field: {},\n\ - \x20 pcs: {},\n\ - \x20 transcript: {},\n\ - }};\n", + "pub const STAGE7_PARAMS: Stage7Params = Stage7Params {{ field: {}, pcs: {}, transcript: {} }};\n", rust_str(&self.params.field), rust_str(&self.params.pcs), rust_str(&self.params.transcript) ), ); - source.push_str(&self.emit_program_step_constants()); - source.push_str(&self.emit_transcript_squeeze_constants()); + source.push_str(&self.emit_program_step_constants()?); + source.push_str(&self.emit_transcript_squeeze_constants()?); source.push_str(&self.emit_transcript_absorb_bytes_constants()); - source.push_str(&self.emit_opening_input_constants()); + source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); - source.push_str(&self.emit_field_expr_constants()); - source + source.push_str(&self.emit_field_expr_constants()?); + Ok(source) } - fn emit_program_step_constants(&self) -> String { + fn emit_program_step_constants(&self) -> Result { let steps = self .steps .iter() .map(|step| { - format!( + Ok(format!( " Stage7ProgramStepPlan {{ kind: {}, symbol: {} }},", - rust_str(&step.kind), + super::plan_tokens::role_program_step_kind_expr( + "Stage7", &self.role, &step.kind + )?, rust_str(&step.symbol), - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE7_PROGRAM_STEPS: &[Stage7ProgramStepPlan] = &[\n{steps}\n];\n\n") + Ok(format!( + "pub const STAGE7_PROGRAM_STEPS: &[Stage7ProgramStepPlan] = &[\n{steps}\n];\n\n" + )) } - fn emit_transcript_squeeze_constants(&self) -> String { + fn emit_transcript_squeeze_constants(&self) -> Result { let squeezes = self .transcript_squeezes .iter() .map(|squeeze| { - format!( + Ok(format!( " Stage7TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},", rust_str(&squeeze.symbol), rust_str(&squeeze.label), - rust_str(&squeeze.kind), + super::plan_tokens::role_transcript_squeeze_kind_expr("Stage7", &self.role, &squeeze.kind)?, squeeze.count, - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE7_TRANSCRIPT_SQUEEZES: &[Stage7TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n" - ) + )) } fn emit_transcript_absorb_bytes_constants(&self) -> String { @@ -1375,12 +1379,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); ) } - fn emit_opening_input_constants(&self) -> String { + fn emit_opening_input_constants(&self) -> Result { let inputs = self .opening_inputs .iter() .map(|input| { - format!( + Ok(format!( " Stage7OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},", rust_str(&input.symbol), rust_str(&input.source_stage), @@ -1388,12 +1392,14 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); rust_str(&input.oracle), rust_str(&input.domain), input.point_arity, - rust_str(&input.claim_kind) - ) + super::plan_tokens::role_claim_kind_expr("Stage7", &self.role, &input.claim_kind)? + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE7_OPENING_INPUTS: &[Stage7OpeningInputPlan] = &[\n{inputs}\n];\n\n") + Ok(format!( + "pub const STAGE7_OPENING_INPUTS: &[Stage7OpeningInputPlan] = &[\n{inputs}\n];\n\n" + )) } fn emit_field_constant_constants(&self) -> String { @@ -1415,7 +1421,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); ) } - fn emit_field_expr_constants(&self) -> String { + fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { let rows = self .field_exprs @@ -1424,22 +1430,26 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); let exprs = chunk .iter() .map(|expr| { - format!( + Ok(format!( "stage7_field_expr!({}, {}, {})", rust_str(&expr.symbol), - rust_str(&expr.formula), + super::plan_tokens::role_field_expr_kind_expr( + "Stage7", + &self.role, + &expr.formula + )?, rust_str(&expr.operands.join("|")) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join(", "); - format!(" {exprs},") + Ok(format!(" {exprs},")) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - return format!( - "macro_rules! stage7_field_expr {{\n ($symbol:literal, $formula:literal, $operands:literal) => {{\n Stage7FieldExprPlan {{ symbol: $symbol, kind: \"op\", formula: $formula, operands: $operands }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[\n{rows}\n];\n" - ); + return Ok(format!( + "macro_rules! stage7_field_expr {{\n ($symbol:literal, $kind:expr, $operands:literal) => {{\n Stage7FieldExprPlan {{ symbol: $symbol, kind: $kind, operands: $operands }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[\n{rows}\n];\n" + )); } let mut source = String::new(); @@ -1481,7 +1491,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); "pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[\n{exprs}\n];\n" ), ); - source + Ok(source) } fn emit_kernel_constants(&self) -> String { @@ -1503,13 +1513,13 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); format!("pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[\n{kernels}\n];\n\n") } - fn emit_sumcheck_claim_constants(&self) -> String { + fn emit_sumcheck_claim_constants(&self) -> Result { if self.role == Role::Verifier { let claims = self .claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage7SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), @@ -1518,16 +1528,20 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); claim.degree, rust_str(&claim.claim), rust_option_str(claim.kernel.as_deref()), - rust_option_str(claim.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage7", + &self.role, + claim.relation.as_deref() + )?, rust_str(&claim.claim_value), rust_str(&claim.input_openings.join("|")) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - return format!( + return Ok(format!( "pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[\n{claims}\n];\n" - ); + )); } let mut source = String::new(); @@ -1542,7 +1556,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); .iter() .enumerate() .map(|(index, claim)| { - format!( + Ok(format!( " Stage7SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: STAGE7_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS }},", rust_str(&claim.symbol), rust_str(&claim.stage), @@ -1551,11 +1565,15 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); claim.degree, rust_str(&claim.claim), rust_option_str(claim.kernel.as_deref()), - rust_option_str(claim.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage7", + &self.role, + claim.relation.as_deref() + )?, rust_str(&claim.claim_value) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); push_format( &mut source, @@ -1563,7 +1581,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); "pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[\n{claims}\n];\n" ), ); - source + Ok(source) } fn emit_sumcheck_batch_constants(&self) -> String { @@ -1646,7 +1664,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); source } - fn emit_sumcheck_driver_constants(&self) -> String { + fn emit_sumcheck_driver_constants(&self) -> Result { let mut source = String::new(); for (index, driver) in self.drivers.iter().enumerate() { source.push_str(&emit_usize_array( @@ -1659,22 +1677,26 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); .iter() .enumerate() .map(|(index, driver)| { - format!( + Ok(format!( " Stage7SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: {}, relation: {}, batch: {}, policy: {}, round_schedule: STAGE7_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},", rust_str(&driver.symbol), rust_str(&driver.stage), rust_str(&driver.proof_slot), rust_option_str(driver.kernel.as_deref()), - rust_option_str(driver.relation.as_deref()), + super::plan_tokens::role_optional_relation_kind_expr( + "Stage7", + &self.role, + driver.relation.as_deref() + )?, rust_str(&driver.batch), rust_str(&driver.policy), rust_str(&driver.claim_label), rust_str(&driver.round_label), driver.num_rounds, driver.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); push_format( &mut source, @@ -1682,46 +1704,50 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); "pub const STAGE7_SUMCHECK_DRIVERS: &[Stage7SumcheckDriverPlan] = &[\n{drivers}\n];\n" ), ); - source + Ok(source) } - fn emit_tail_constants(&self) -> String { + fn emit_tail_constants(&self) -> Result { let mut source = String::new(); - source.push_str(&self.emit_sumcheck_instance_result_constants()); + source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); source.push_str(&self.emit_point_zero_constants()); source.push_str(&self.emit_point_slice_constants()); source.push_str(&self.emit_point_concat_constants()); - source.push_str(&self.emit_opening_claim_constants()); - source.push_str(&self.emit_opening_claim_equality_constants()); + source.push_str(&self.emit_opening_claim_constants()?); + source.push_str(&self.emit_opening_claim_equality_constants()?); source.push_str(&self.emit_opening_batch_constants()); - source + Ok(source) } - fn emit_sumcheck_instance_result_constants(&self) -> String { + fn emit_sumcheck_instance_result_constants(&self) -> Result { let instances = self .instance_results .iter() .map(|instance| { - format!( + Ok(format!( " Stage7SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},", rust_str(&instance.symbol), rust_str(&instance.source), rust_str(&instance.claim), - rust_str(&instance.relation), + super::plan_tokens::role_relation_kind_expr( + "Stage7", + &self.role, + &instance.relation + )?, instance.index, instance.point_arity, instance.num_rounds, instance.round_offset, rust_str(&instance.point_order), instance.degree - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n" - ) + )) } fn emit_sumcheck_eval_constants(&self) -> String { @@ -1839,45 +1865,47 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); source } - fn emit_opening_claim_constants(&self) -> String { + fn emit_opening_claim_constants(&self) -> Result { let claims = self .opening_claims .iter() .map(|claim| { - format!( + Ok(format!( " Stage7OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},", rust_str(&claim.symbol), rust_str(&claim.oracle), rust_str(&claim.domain), claim.point_arity, - rust_str(&claim.claim_kind), + super::plan_tokens::role_claim_kind_expr("Stage7", &self.role, &claim.claim_kind)?, rust_str(&claim.point_source), rust_str(&claim.eval_source) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!("pub const STAGE7_OPENING_CLAIMS: &[Stage7OpeningClaimPlan] = &[\n{claims}\n];\n\n") + Ok(format!( + "pub const STAGE7_OPENING_CLAIMS: &[Stage7OpeningClaimPlan] = &[\n{claims}\n];\n\n" + )) } - fn emit_opening_claim_equality_constants(&self) -> String { + fn emit_opening_claim_equality_constants(&self) -> Result { let equalities = self .opening_equalities .iter() .map(|equality| { - format!( + Ok(format!( " Stage7OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},", rust_str(&equality.symbol), - rust_str(&equality.mode), + super::plan_tokens::role_opening_equality_mode_expr("Stage7", &self.role, &equality.mode)?, rust_str(&equality.lhs), rust_str(&equality.rhs) - ) + )) }) - .collect::>() + .collect::, EmitError>>()? .join("\n"); - format!( + Ok(format!( "pub const STAGE7_OPENING_EQUALITIES: &[Stage7OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n" - ) + )) } fn emit_opening_batch_constants(&self) -> String { @@ -2000,14 +2028,14 @@ where let mut artifacts = Stage7ExecutionArtifacts::default(); for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage7ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage7Error::MissingValue { symbol: step.symbol, })?; verify_stage7_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "transcript_absorb_bytes" => { + Stage7ProgramStepKind::TranscriptAbsorbBytes => { let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or( VerifyStage7Error::MissingValue { symbol: step.symbol, @@ -2015,7 +2043,7 @@ where )?; absorb_stage7_bytes(absorb, transcript); } - "sumcheck_driver" => { + Stage7ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage7Error::MissingProof { driver: step.symbol, @@ -2029,12 +2057,6 @@ where &mut artifacts, )?; } - _ => { - return Err(VerifyStage7Error::InvalidProof { - driver: step.symbol, - reason: "unsupported stage7 program step", - }); - } } } artifacts @@ -2103,12 +2125,17 @@ where .ok_or(VerifyStage7Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage7Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage7.batched" => { + Stage7RelationKind::Stage7Batched => { verify_batched_stage7(program, driver, proof, store, transcript)? } - _ => return Err(VerifyStage7Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); Ok(()) @@ -2156,9 +2183,7 @@ fn observe_stage7_sumcheck_output( match instance.point_order { "as_is" => {} "reverse" => point.reverse(), - "bytecode_read_raf" => point = normalize_bytecode_read_raf_point(&point, stage7_trace_rounds(program)?, "stage7.bytecode_read_raf.point")?, "stage7_booleanity" => {} - "instruction_read_raf" => point = normalize_instruction_read_raf_point(&point, "stage7.instruction_read_raf.point")?, _ => { return Err(VerifyStage7Error::InvalidProof { driver: output.driver, @@ -2221,12 +2246,17 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let relation = claim.relation.unwrap_or(""); + let Some(relation) = claim.relation else { + return Err(VerifyStage7Error::InvalidProof { + driver: driver.symbol, + reason: "missing claim relation", + }); + }; let value = match relation { - "jolt.stage7.hamming_weight_claim_reduction" => { + Stage7RelationKind::Stage7HammingWeightClaimReduction => { expected_hamming_weight_claim_reduction(program, driver, store, evals, local_point)? } - _ => return Err(VerifyStage7Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; } @@ -2301,19 +2331,6 @@ fn stage7_virtualization_point<'a>( actual: point.len(), }) } - -fn stage7_trace_rounds( - program: &'static Stage7VerifierProgramPlan, -) -> Result { - program - .instance_results - .iter() - .find(|instance| instance.relation == "jolt.stage7.hamming_booleanity") - .map(|instance| instance.num_rounds) - .ok_or(VerifyStage7Error::MissingValue { - symbol: "stage7.hamming_booleanity.instance", - }) -} "# } } @@ -2362,10 +2379,10 @@ fn emit_str_array(name: &str, values: &[String]) -> String { fn emit_usize_array(name: &str, values: &[usize]) -> String { let entries = values .iter() - .map(|value| format!(" {value},")) + .map(usize::to_string) .collect::>() - .join("\n"); - format!("pub const {name}: &[usize] = &[\n{entries}\n];\n\n") + .join(", "); + format!("pub const {name}: &[usize] = &[{entries}];\n\n") } fn intern_str_array( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs index 9914b4b4cf..4d19a26a70 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs @@ -237,6 +237,19 @@ impl Stage8CpuProgram { "stage8 opening batch ordered claims do not match SSA operands", )); } + let batch_symbols = self + .opening_batches + .iter() + .map(|batch| batch.symbol.as_str()) + .collect::>(); + for proof in &self.pcs_proofs { + if !batch_symbols.contains(proof.batch.as_str()) { + return Err(EmitError::new(format!( + "stage8 PCS proof `{}` references missing opening batch `{}`", + proof.symbol, proof.batch + ))); + } + } if !self .opening_inputs .iter() @@ -278,38 +291,51 @@ impl Stage8CpuProgram { fn emit_source(&self) -> Result { let mut source = String::new(); source.push_str("#![allow(clippy::too_many_lines)]\n\n"); + match self.role { + Role::Verifier => source.push_str( + "pub use super::common::{ClaimKind as Stage8ClaimKind, PcsProofMode as Stage8PcsProofMode, SourceStage as Stage8SourceStage, StageParams as Stage8Params, TypedPlanSymbol};\n\n\ + pub enum Stage8OpeningInputTag {}\n\ + pub type Stage8OpeningInputSymbol = TypedPlanSymbol;\n\ + pub enum Stage8OpeningClaimTag {}\n\ + pub type Stage8OpeningClaimSymbol = TypedPlanSymbol;\n\ + pub enum Stage8OpeningBatchTag {}\n\ + pub type Stage8OpeningBatchSymbol = TypedPlanSymbol;\n\ + pub enum Stage8SourceClaimTag {}\n\ + pub type Stage8SourceClaim = TypedPlanSymbol;\n\n", + ), + Role::Prover => source.push_str(prover_local_plan_types()), + } source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n"); source.push_str( - "pub struct Stage8Params {\n pub field: &'static str,\n pub pcs: &'static str,\n pub transcript: &'static str,\n}\n\n", - ); - source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n"); - source.push_str( - "pub struct Stage8OpeningInputPlan {\n pub symbol: &'static str,\n pub source_stage: &'static str,\n pub source_claim: &'static str,\n pub oracle: &'static str,\n pub domain: &'static str,\n pub point_arity: usize,\n pub claim_kind: &'static str,\n}\n\n", + "pub struct Stage8OpeningInputPlan {\n pub symbol: Stage8OpeningInputSymbol,\n pub source_stage: Stage8SourceStage,\n pub source_claim: Stage8SourceClaim,\n pub oracle: &'static str,\n pub domain: &'static str,\n pub point_arity: usize,\n pub claim_kind: Stage8ClaimKind,\n}\n\n", ); source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n"); source.push_str( - "pub struct Stage8OpeningClaimPlan {\n pub symbol: &'static str,\n pub oracle: &'static str,\n pub family: &'static str,\n pub domain: &'static str,\n pub point_arity: usize,\n pub point_source: &'static str,\n pub eval_source: &'static str,\n pub source_stage: &'static str,\n pub source_claim: &'static str,\n}\n\n", + "pub struct Stage8OpeningClaimPlan {\n pub symbol: Stage8OpeningClaimSymbol,\n pub oracle: &'static str,\n pub family: &'static str,\n pub domain: &'static str,\n pub point_arity: usize,\n pub point_source: Stage8OpeningInputSymbol,\n pub eval_source: Stage8OpeningInputSymbol,\n pub source_stage: Stage8SourceStage,\n pub source_claim: Stage8SourceClaim,\n}\n\n", ); source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n"); source.push_str( - "pub struct Stage8OpeningBatchPlan {\n pub symbol: &'static str,\n pub proof_slot: &'static str,\n pub policy: &'static str,\n pub count: usize,\n pub ordered_claims: &'static [&'static str],\n}\n\n", + "pub struct Stage8OpeningBatchPlan {\n pub symbol: Stage8OpeningBatchSymbol,\n pub proof_slot: &'static str,\n pub policy: &'static str,\n pub count: usize,\n pub ordered_claims: &'static [Stage8OpeningClaimPlan],\n}\n\n", ); + if self.role == Role::Prover { + source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n"); + source.push_str("pub enum Stage8PcsProofMode {\n Open,\n Verify,\n}\n\n"); + } source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n"); source.push_str( - "pub struct Stage8PcsProofPlan {\n pub symbol: &'static str,\n pub mode: &'static str,\n pub pcs: &'static str,\n pub proof_slot: &'static str,\n pub transcript_label: &'static str,\n pub batch: &'static str,\n}\n\n", + "pub struct Stage8PcsProofPlan {\n pub symbol: &'static str,\n pub mode: Stage8PcsProofMode,\n pub pcs: &'static str,\n pub proof_slot: &'static str,\n pub transcript_label: &'static str,\n pub batch: Stage8OpeningBatchSymbol,\n}\n\n", ); source.push_str("#[derive(Clone, Copy, Debug, PartialEq, Eq)]\n"); source.push_str( "pub struct Stage8EvaluationProgramPlan {\n pub role: &'static str,\n pub function: &'static str,\n pub params: Stage8Params,\n pub evaluation_point_source: Stage8OpeningInputPlan,\n pub opening_inputs: &'static [Stage8OpeningInputPlan],\n pub opening_claims: &'static [Stage8OpeningClaimPlan],\n pub opening_batch: Stage8OpeningBatchPlan,\n pub pcs_proof: Stage8PcsProofPlan,\n}\n\n", ); + source.push_str(stage8_evaluation_helpers()); push_format( &mut source, format_args!( - "pub const STAGE8_PARAMS: Stage8Params = Stage8Params {{ field: {}, pcs: {}, transcript: {} }};\n\n", - rust_str(&self.params.field), - rust_str(&self.params.pcs), - rust_str(&self.params.transcript), + "pub const STAGE8_PARAMS: Stage8Params = {};\n\n", + params_literal(&self.params), ), ); let point_source = self @@ -325,33 +351,26 @@ impl Stage8CpuProgram { &mut source, format_args!( "pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = {};\n\n", - opening_input_literal(point_source), + opening_input_literal(point_source)?, ), ); - source.push_str("pub const STAGE8_OPENING_INPUTS: &[Stage8OpeningInputPlan] = &[\n"); + source.push_str( + "#[rustfmt::skip]\npub const STAGE8_OPENING_INPUTS: &[Stage8OpeningInputPlan] = &[\n", + ); for input in &self.opening_inputs { push_format( &mut source, - format_args!(" {},\n", opening_input_literal(input)), + format_args!(" {},\n", opening_input_literal(input)?), ); } source.push_str("];\n\n"); - source.push_str("pub const STAGE8_OPENING_CLAIMS: &[Stage8OpeningClaimPlan] = &[\n"); + source.push_str( + "#[rustfmt::skip]\npub const STAGE8_OPENING_CLAIMS: &[Stage8OpeningClaimPlan] = &[\n", + ); for claim in &self.opening_claims { push_format( &mut source, - format_args!( - " Stage8OpeningClaimPlan {{ symbol: {}, oracle: {}, family: {}, domain: {}, point_arity: {}, point_source: {}, eval_source: {}, source_stage: {}, source_claim: {} }},\n", - rust_str(&claim.symbol), - rust_str(&claim.oracle), - rust_str(&claim.family), - rust_str(&claim.domain), - claim.point_arity, - rust_str(&claim.point_source), - rust_str(&claim.eval_source), - rust_str(&claim.source_stage), - rust_str(&claim.source_claim), - ), + format_args!(" {},\n", opening_claim_literal(claim)?), ); } source.push_str("];\n\n"); @@ -359,37 +378,22 @@ impl Stage8CpuProgram { push_format( &mut source, format_args!( - "pub const STAGE8_OPENING_BATCH_ORDERED_CLAIMS: &[&str] = &{};\n\n", - rust_str_array(&batch.ordered_claims), - ), - ); - push_format( - &mut source, - format_args!( - "pub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = Stage8OpeningBatchPlan {{ symbol: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: STAGE8_OPENING_BATCH_ORDERED_CLAIMS }};\n\n", - rust_str(&batch.symbol), - rust_str(&batch.proof_slot), - rust_str(&batch.policy), - batch.count, + "#[rustfmt::skip]\npub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = {};\n\n", + opening_batch_literal(batch), ), ); let proof = &self.pcs_proofs[0]; push_format( &mut source, format_args!( - "pub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = Stage8PcsProofPlan {{ symbol: {}, mode: {}, pcs: {}, proof_slot: {}, transcript_label: {}, batch: {} }};\n\n", - rust_str(&proof.symbol), - rust_str(&proof.mode), - rust_str(&proof.pcs), - rust_str(&proof.proof_slot), - rust_str(&proof.transcript_label), - rust_str(&proof.batch), + "#[rustfmt::skip]\npub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = {};\n\n", + pcs_proof_literal(proof)?, ), ); push_format( &mut source, format_args!( - "pub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan {{\n role: {},\n function: {},\n params: STAGE8_PARAMS,\n evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE,\n opening_inputs: STAGE8_OPENING_INPUTS,\n opening_claims: STAGE8_OPENING_CLAIMS,\n opening_batch: STAGE8_OPENING_BATCH,\n pcs_proof: STAGE8_PCS_PROOF,\n}};\n", + "#[rustfmt::skip]\npub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan {{ role: {}, function: {}, params: STAGE8_PARAMS, evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE, opening_inputs: STAGE8_OPENING_INPUTS, opening_claims: STAGE8_OPENING_CLAIMS, opening_batch: STAGE8_OPENING_BATCH, pcs_proof: STAGE8_PCS_PROOF }};\n", rust_str(self.role.as_str()), rust_str(&self.function), ), @@ -398,30 +402,364 @@ impl Stage8CpuProgram { } } -fn opening_input_literal(input: &Stage8OpeningInputPlan) -> String { +fn params_literal(params: &Stage8Params) -> String { format!( + "Stage8Params {{ field: {}, pcs: {}, transcript: {} }}", + rust_str(¶ms.field), + rust_str(¶ms.pcs), + rust_str(¶ms.transcript), + ) +} + +fn prover_local_plan_types() -> &'static str { + r#"#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage8Params { + pub field: &'static str, + pub pcs: &'static str, + pub transcript: &'static str, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage8ClaimKind { + Committed, + Virtual, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage8SourceStage { + Stage6, + Stage7, +} + +impl Stage8SourceStage { + pub fn as_str(self) -> &'static str { + match self { + Self::Stage6 => "stage6", + Self::Stage7 => "stage7", + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct Stage8OpeningInputSymbol(&'static str); + +impl Stage8OpeningInputSymbol { + pub const fn new(symbol: &'static str) -> Self { + Self(symbol) + } + + pub fn as_str(self) -> &'static str { + self.0 + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct Stage8OpeningClaimSymbol(&'static str); + +impl Stage8OpeningClaimSymbol { + pub const fn new(symbol: &'static str) -> Self { + Self(symbol) + } + + pub fn as_str(self) -> &'static str { + self.0 + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct Stage8OpeningBatchSymbol(&'static str); + +impl Stage8OpeningBatchSymbol { + pub const fn new(symbol: &'static str) -> Self { + Self(symbol) + } + + pub fn as_str(self) -> &'static str { + self.0 + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct Stage8SourceClaim(&'static str); + +impl Stage8SourceClaim { + pub const fn new(symbol: &'static str) -> Self { + Self(symbol) + } + + pub fn as_str(self) -> &'static str { + self.0 + } +} + +"# +} + +fn stage8_evaluation_helpers() -> &'static str { + r#"#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage8EvaluationClaim { + pub oracle: &'static str, + pub source_stage: Stage8SourceStage, + pub value: F, +} + +pub fn reverse_point(point: &[F]) -> Vec { + point.iter().rev().copied().collect() +} + +pub fn append_rlc_claims(transcript: &mut T, claims: &[Stage8EvaluationClaim]) +where + F: jolt_field::Field + jolt_transcript::AppendToTranscript, + T: jolt_transcript::Transcript, +{ + transcript.append(&jolt_transcript::LabelWithCount( + b"rlc_claims", + claims.len() as u64, + )); + for claim in claims { + jolt_transcript::AppendToTranscript::append_to_transcript(&claim.value, transcript); + } +} + +pub fn gamma_powers(transcript: &mut T, count: usize) -> Vec +where + F: jolt_field::Field, + T: jolt_transcript::Transcript, +{ + let gamma = transcript.challenge(); + let mut powers = Vec::with_capacity(count); + let mut power = F::from_u64(1); + for _ in 0..count { + powers.push(power); + power *= gamma; + } + powers +} + +pub trait Stage8NamedEvalView { + fn name(&self) -> &'static str; + fn value(&self) -> F; +} + +pub trait Stage8SumcheckOutputView { + type Eval: Stage8NamedEvalView; + + fn point(&self) -> &[F]; + fn evals(&self) -> &[Self::Eval]; +} + +pub fn stage7_claim_values( + program: &'static Stage8EvaluationProgramPlan, + outputs: &[O], +) -> Option<(Vec, std::collections::BTreeMap)> +where + F: Copy, + O: Stage8SumcheckOutputView, +{ + let stage7_plans = program + .opening_claims + .iter() + .filter(|plan| plan.source_stage == Stage8SourceStage::Stage7) + .collect::>(); + for output in outputs { + let mut values = std::collections::BTreeMap::new(); + for plan in &stage7_plans { + if let Some(eval) = output + .evals() + .iter() + .find(|eval| eval.name() == plan.source_claim.as_str()) + { + let _ = values.insert(plan.source_claim, eval.value()); + } + } + if values.len() == stage7_plans.len() { + return Some((output.point().to_vec(), values)); + } + } + None +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage8EvaluationClaimError { + pub stage: &'static str, + pub eval: &'static str, +} + +pub fn evaluation_claims( + program: &'static Stage8EvaluationProgramPlan, + stage6_outputs: &[O], + stage7_values: &std::collections::BTreeMap, + lagrange_factor: F, +) -> Result>, Stage8EvaluationClaimError> +where + F: Copy + std::ops::Mul, + O: Stage8SumcheckOutputView, +{ + let mut claims = Vec::with_capacity(program.opening_claims.len()); + for plan in program.opening_claims { + let value = match plan.source_stage { + Stage8SourceStage::Stage6 => { + stage_eval(stage6_outputs, plan.source_stage.as_str(), plan.source_claim)? + * lagrange_factor + } + Stage8SourceStage::Stage7 => *stage7_values.get(&plan.source_claim).ok_or( + Stage8EvaluationClaimError { + stage: plan.source_stage.as_str(), + eval: plan.source_claim.as_str(), + }, + )?, + }; + claims.push(Stage8EvaluationClaim { + oracle: plan.oracle, + source_stage: plan.source_stage, + value, + }); + } + Ok(claims) +} + +fn stage_eval( + outputs: &[O], + stage: &'static str, + eval_name: Stage8SourceClaim, +) -> Result +where + F: Copy, + O: Stage8SumcheckOutputView, +{ + for output in outputs { + let eval = output + .evals() + .iter() + .find(|eval| eval.name() == eval_name.as_str()); + if let Some(eval) = eval { return Ok(eval.value()); } + } + Err(Stage8EvaluationClaimError { + stage, + eval: eval_name.as_str(), + }) +} + +pub trait Stage8OpeningInputView { + fn symbol(&self) -> &'static str; + fn point(&self) -> &[F]; +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage8EvaluationOpeningPointError { + MissingStage7EvaluationPoint, + InvalidPointLength { + artifact: &'static str, + expected: usize, + actual: usize, + }, +} + +pub fn stage7_evaluation_opening_point( + program: &'static Stage8EvaluationProgramPlan, + address_point: &[F], + stage7_openings: &[I], +) -> Result<(Vec, usize), Stage8EvaluationOpeningPointError> +where + F: Copy, + I: Stage8OpeningInputView, +{ + let cycle_source_symbol = program.evaluation_point_source.source_claim; + let cycle_source = stage7_openings + .iter() + .find(|input| input.symbol() == cycle_source_symbol.as_str()) + .ok_or(Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint)?; + let cycle_source_point = cycle_source.point(); + if cycle_source_point.len() < address_point.len() { + return Err(Stage8EvaluationOpeningPointError::InvalidPointLength { + artifact: cycle_source_symbol.as_str(), + expected: address_point.len(), + actual: cycle_source_point.len(), + }); + } + let cycle_len = cycle_source_point.len() - address_point.len(); + let mut point = Vec::with_capacity(cycle_source_point.len()); + point.extend_from_slice(address_point); + point.extend_from_slice(&cycle_source_point[address_point.len()..]); + Ok((point, cycle_len)) +} + +"# +} + +fn opening_input_literal(input: &Stage8OpeningInputPlan) -> Result { + Ok(format!( "Stage8OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }}", - rust_str(&input.symbol), - rust_str(&input.source_stage), - rust_str(&input.source_claim), + symbol_expr("Stage8OpeningInputSymbol", &input.symbol), + source_stage_expr(&input.source_stage)?, + source_claim_expr(&input.source_claim), rust_str(&input.oracle), rust_str(&input.domain), input.point_arity, - rust_str(&input.claim_kind), + super::plan_tokens::claim_kind_expr("Stage8", &input.claim_kind)?, + )) +} + +fn opening_claim_literal(claim: &Stage8OpeningClaimPlan) -> Result { + Ok(format!( + "Stage8OpeningClaimPlan {{ symbol: {}, oracle: {}, family: {}, domain: {}, point_arity: {}, point_source: {}, eval_source: {}, source_stage: {}, source_claim: {} }}", + symbol_expr("Stage8OpeningClaimSymbol", &claim.symbol), + rust_str(&claim.oracle), + rust_str(&claim.family), + rust_str(&claim.domain), + claim.point_arity, + symbol_expr("Stage8OpeningInputSymbol", &claim.point_source), + symbol_expr("Stage8OpeningInputSymbol", &claim.eval_source), + source_stage_expr(&claim.source_stage)?, + source_claim_expr(&claim.source_claim), + )) +} + +fn source_stage_expr(source_stage: &str) -> Result { + let variant = match source_stage { + "stage6" => "Stage6", + "stage7" => "Stage7", + _ => { + return Err(EmitError::new(format!( + "unsupported Stage 8 source stage `{source_stage}`" + ))) + } + }; + Ok(format!("Stage8SourceStage::{variant}")) +} + +fn symbol_expr(type_name: &str, symbol: &str) -> String { + format!("{type_name}::new({})", rust_str(symbol)) +} + +fn source_claim_expr(source_claim: &str) -> String { + format!("Stage8SourceClaim::new({})", rust_str(source_claim)) +} + +fn opening_batch_literal(batch: &Stage8OpeningBatchPlan) -> String { + format!( + "Stage8OpeningBatchPlan {{ symbol: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: STAGE8_OPENING_CLAIMS }}", + symbol_expr("Stage8OpeningBatchSymbol", &batch.symbol), + rust_str(&batch.proof_slot), + rust_str(&batch.policy), + batch.count, ) } -fn rust_str(value: &str) -> String { - format!("{value:?}") +fn pcs_proof_literal(proof: &Stage8PcsProofPlan) -> Result { + Ok(format!( + "Stage8PcsProofPlan {{ symbol: {}, mode: {}, pcs: {}, proof_slot: {}, transcript_label: {}, batch: {} }}", + rust_str(&proof.symbol), + super::plan_tokens::pcs_proof_mode_expr("Stage8", &proof.mode)?, + rust_str(&proof.pcs), + rust_str(&proof.proof_slot), + rust_str(&proof.transcript_label), + symbol_expr("Stage8OpeningBatchSymbol", &proof.batch), + )) } -fn rust_str_array(values: &[String]) -> String { - let values = values - .iter() - .map(|value| rust_str(value)) - .collect::>() - .join(", "); - format!("[{values}]") +fn rust_str(value: &str) -> String { + format!("{value:?}") } fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { diff --git a/crates/bolt/src/protocols/jolt/verifier_common.rs.template b/crates/bolt/src/protocols/jolt/verifier_common.rs.template index 493e9e9395..91b706f1dc 100644 --- a/crates/bolt/src/protocols/jolt/verifier_common.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_common.rs.template @@ -3,8 +3,12 @@ reason = "generated verifier helpers mirror staged protocol ABIs" )] +use std::cmp::Ordering; +use std::fmt; +use std::marker::PhantomData; + use jolt_field::{Field, Fr, MulPow2, RingCore}; -use jolt_poly::EqPolynomial; +use jolt_poly::{lagrange::lagrange_evals, EqPolynomial}; use jolt_sumcheck::{ CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier, }; @@ -18,6 +22,61 @@ pub struct StageParams { pub transcript: &'static str, } +pub struct TypedPlanSymbol { + symbol: &'static str, + _tag: PhantomData Tag>, +} + +impl TypedPlanSymbol { + pub(crate) const fn new(symbol: &'static str) -> Self { + Self { + symbol, + _tag: PhantomData, + } + } + + pub fn as_str(self) -> &'static str { + self.symbol + } +} + +impl Clone for TypedPlanSymbol { + fn clone(&self) -> Self { + *self + } +} + +impl Copy for TypedPlanSymbol {} + +impl fmt::Debug for TypedPlanSymbol { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter + .debug_tuple("TypedPlanSymbol") + .field(&self.symbol) + .finish() + } +} + +impl PartialEq for TypedPlanSymbol { + fn eq(&self, other: &Self) -> bool { + self.symbol == other.symbol + } +} + +impl Eq for TypedPlanSymbol {} + +impl PartialOrd for TypedPlanSymbol { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for TypedPlanSymbol { + fn cmp(&self, other: &Self) -> Ordering { + self.symbol.cmp(other.symbol) + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct KernelPlan { pub symbol: &'static str, @@ -27,11 +86,28 @@ pub struct KernelPlan { pub abi: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[rustfmt::skip] +pub enum RelationKind { Stage1OuterUniskip, Stage1OuterRemaining, Stage2ProductVirtualUniskip, Stage2RamReadWrite, Stage2ProductVirtualRemainder, Stage2InstructionLookupClaimReduction, Stage2RamRafEvaluation, Stage2RamOutputCheck, Stage2Batched, Stage3SpartanShift, Stage3InstructionInput, Stage3RegistersClaimReduction, Stage3Batched, Stage4RegistersReadWrite, Stage4RamValCheck, Stage4Batched, Stage5InstructionReadRaf, Stage5RamRaClaimReduction, Stage5RegistersValEvaluation, Stage5Batched, Stage6BytecodeReadRaf, Stage6Booleanity, Stage6HammingBooleanity, Stage6RamRaVirtual, Stage6InstructionRaVirtual, Stage6IncClaimReduction, Stage6Batched, Stage7HammingWeightClaimReduction, Stage7Batched } + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum TranscriptSqueezeKind { + ChallengeScalar, + ChallengeVector, + Scalar, +} + +impl TranscriptSqueezeKind { + pub fn is_scalar(self) -> bool { + matches!(self, Self::ChallengeScalar | Self::Scalar) + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct TranscriptSqueezePlan { pub symbol: &'static str, pub label: &'static str, - pub kind: &'static str, + pub kind: TranscriptSqueezeKind, pub count: usize, } @@ -42,12 +118,46 @@ pub struct TranscriptAbsorbBytesPlan { pub payload: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ProgramStepKind { + TranscriptSqueeze, + TranscriptAbsorbBytes, + SumcheckDriver, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct ProgramStepPlan { - pub kind: &'static str, + pub kind: ProgramStepKind, pub symbol: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ClaimKind { + Committed, + Virtual, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SourceStage { + Stage6, + Stage7, +} + +impl SourceStage { + pub fn as_str(self) -> &'static str { + match self { + Self::Stage6 => "stage6", + Self::Stage7 => "stage7", + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum PcsProofMode { + Open, + Verify, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct OpeningInputPlan { pub symbol: &'static str, @@ -56,7 +166,7 @@ pub struct OpeningInputPlan { pub oracle: &'static str, pub domain: &'static str, pub point_arity: usize, - pub claim_kind: &'static str, + pub claim_kind: ClaimKind, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -66,11 +176,21 @@ pub struct FieldConstantPlan { pub value: usize, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum FieldExprKind { + OpeningEval, + Add, + Sub, + Mul, + Neg, + Pow(usize), + LagrangeBasisEval(i64, usize, usize), +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct FieldExprPlan { pub symbol: &'static str, - pub kind: &'static str, - pub formula: &'static str, + pub kind: FieldExprKind, pub operands: &'static str, } @@ -83,7 +203,7 @@ pub struct SumcheckClaimPlan { pub degree: usize, pub claim: &'static str, pub kernel: Option<&'static str>, - pub relation: Option<&'static str>, + pub relation: Option, pub claim_value: &'static str, pub input_openings: &'static str, } @@ -108,7 +228,7 @@ pub struct SumcheckDriverPlan { pub stage: &'static str, pub proof_slot: &'static str, pub kernel: Option<&'static str>, - pub relation: Option<&'static str>, + pub relation: Option, pub batch: &'static str, pub policy: &'static str, pub round_schedule: &'static [usize], @@ -123,7 +243,7 @@ pub struct SumcheckInstanceResultPlan { pub symbol: &'static str, pub source: &'static str, pub claim: &'static str, - pub relation: &'static str, + pub relation: RelationKind, pub index: usize, pub point_arity: usize, pub num_rounds: usize, @@ -171,15 +291,20 @@ pub struct OpeningClaimPlan { pub oracle: &'static str, pub domain: &'static str, pub point_arity: usize, - pub claim_kind: &'static str, + pub claim_kind: ClaimKind, pub point_source: &'static str, pub eval_source: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum OpeningEqualityMode { + PointAndEval, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct OpeningClaimEqualityPlan { pub symbol: &'static str, - pub mode: &'static str, + pub mode: OpeningEqualityMode, pub lhs: &'static str, pub rhs: &'static str, } @@ -366,10 +491,6 @@ pub enum RuntimePlanError { driver: &'static str, reason: &'static str, }, - UnsupportedFieldExpr { - symbol: &'static str, - formula: &'static str, - }, } macro_rules! impl_runtime_plan_error_conversion { @@ -398,9 +519,6 @@ macro_rules! impl_runtime_plan_error_conversion { super::common::RuntimePlanError::InvalidProof { driver, reason } => { Self::InvalidProof { driver, reason } } - super::common::RuntimePlanError::UnsupportedFieldExpr { symbol, formula } => { - Self::UnsupportedFieldExpr { symbol, formula } - } } } } @@ -556,7 +674,7 @@ impl ValueStore { invalid_input_length: impl Fn(&'static str, usize, usize) -> E, ) -> Result<(), E> { self.insert_point(plan.symbol, values.to_vec()); - if matches!(plan.kind, "challenge_scalar" | "scalar") { + if plan.kind.is_scalar() { if values.len() != 1 { return Err(invalid_input_length(plan.symbol, 1, values.len())); } @@ -678,7 +796,7 @@ impl ValueStore { ) -> Result<(), E> { for equality in opening_equalities { match equality.mode { - "point_and_eval" => { + OpeningEqualityMode::PointAndEval => { if self.point_or(equality.lhs, &missing_value)? != self.point_or(equality.rhs, &missing_value)? || self.scalar_or(equality.lhs, &missing_value)? @@ -690,12 +808,6 @@ impl ValueStore { )); } } - _ => { - return Err(invalid_proof( - equality.symbol, - "unsupported opening equality mode", - )); - } } } Ok(()) @@ -1012,39 +1124,39 @@ pub fn evaluate_field_expr( expr: &FieldExprPlan, operands: &[F], ) -> Result { - match expr.formula { - "opening_eval" => Ok(single_operand(expr.symbol, operands)?), - "field.add" => { + match expr.kind { + FieldExprKind::OpeningEval => Ok(single_operand(expr.symbol, operands)?), + FieldExprKind::Add => { require_operand_count(expr.symbol, 2, operands.len())?; Ok(operands[0] + operands[1]) } - "field.sub" => { + FieldExprKind::Sub => { require_operand_count(expr.symbol, 2, operands.len())?; Ok(operands[0] - operands[1]) } - "field.mul" => { + FieldExprKind::Mul => { require_operand_count(expr.symbol, 2, operands.len())?; Ok(operands[0] * operands[1]) } - "field.neg" => { + FieldExprKind::Neg => { require_operand_count(expr.symbol, 1, operands.len())?; Ok(-operands[0]) } - formula => { - if let Some(exponent) = formula.strip_prefix("field.pow:") { - require_operand_count(expr.symbol, 1, operands.len())?; - let exponent = exponent.parse::().map_err(|_| { - RuntimePlanError::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - } - })?; - return Ok(pow_field(operands[0], exponent)); - } - Err(RuntimePlanError::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - }) + FieldExprKind::Pow(exponent) => { + require_operand_count(expr.symbol, 1, operands.len())?; + Ok(pow_field(operands[0], exponent)) + } + FieldExprKind::LagrangeBasisEval(domain_start, domain_size, index) => { + require_operand_count(expr.symbol, 1, operands.len())?; + let weights = lagrange_evals(domain_start, domain_size, operands[0]); + weights + .get(index) + .copied() + .ok_or(RuntimePlanError::InvalidInputLength { + input: expr.symbol, + expected: index + 1, + actual: weights.len(), + }) } } } @@ -1149,7 +1261,6 @@ pub fn normalize_instruction_read_raf_point( #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage67RelationSymbols { - pub hamming_booleanity_relation: &'static str, pub hamming_booleanity_instance: &'static str, pub booleanity_point: &'static str, pub stage5_instruction_ra0: &'static str, @@ -1226,7 +1337,7 @@ pub fn stage67_trace_rounds( ) -> Result { instance_results .iter() - .find(|instance| instance.relation == symbols.hamming_booleanity_relation) + .find(|instance| instance.relation == RelationKind::Stage6HammingBooleanity) .map(|instance| instance.num_rounds) .ok_or(RuntimePlanError::MissingValue { symbol: symbols.hamming_booleanity_instance, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 88c2f987de..e9f71c2d73 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1308,7 +1308,7 @@ fn stage4_rust_targets_extract_and_compile() { .contains("Stage4TranscriptAbsorbBytesPlan")); assert!(verifier_source .source - .contains("relation: Some(\"jolt.stage4.batched\")")); + .contains("relation: Some(Stage4RelationKind::Stage4Batched)")); assert!(verifier_source.source.contains("Stage4VerifierProgramPlan")); assert!(verifier_source.source.contains("pub fn verify_stage4")); assert!(verifier_source.source.contains("LabelWithCount")); @@ -1394,13 +1394,13 @@ fn stage5_rust_targets_extract_and_compile() { assert!(verifier_source.source.contains("pub fn verify_stage5")); assert!(verifier_source .source - .contains("relation: Some(\"jolt.stage5.batched\")")); + .contains("relation: Some(Stage5RelationKind::Stage5Batched)")); assert!(verifier_source .source .contains("expected_instruction_read_raf")); assert!(verifier_source .source - .contains("jolt.stage5.instruction_read_raf")); + .contains("Stage5RelationKind::Stage5InstructionReadRaf")); assert!(verifier_source .source .contains("LookupTableKind::::all")); @@ -1415,10 +1415,10 @@ fn stage5_rust_targets_extract_and_compile() { .contains("expected_registers_val_evaluation")); assert!(verifier_source .source - .contains("jolt.stage5.ram_ra_claim_reduction")); + .contains("Stage5RelationKind::Stage5RamRaClaimReduction")); assert!(verifier_source .source - .contains("jolt.stage5.registers_val_evaluation")); + .contains("Stage5RelationKind::Stage5RegistersValEvaluation")); assert!(verifier_source.source.contains("LookupTableFlag_40")); assert!(!verifier_source.source.contains("LookupTableFlag_41")); assert!(verifier_source @@ -1537,10 +1537,10 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source.source.contains("pub fn verify_stage6")); assert!(verifier_source .source - .contains("relation: Some(\"jolt.stage6.batched\")")); + .contains("relation: Some(Stage6RelationKind::Stage6Batched)")); assert!(verifier_source .source - .contains("jolt.stage6.bytecode_read_raf")); + .contains("Stage6RelationKind::Stage6BytecodeReadRaf")); assert!(verifier_source.source.contains("Stage6VerifierData")); assert!(verifier_source.source.contains("Stage6BytecodeReadRafData")); assert!(verifier_source.source.contains("Stage6BytecodeEntry")); @@ -1556,7 +1556,7 @@ fn stage6_rust_targets_extract_and_compile() { .contains("expected_hamming_booleanity")); assert!(verifier_source .source - .contains("jolt.stage6.inc_claim_reduction")); + .contains("Stage6RelationKind::Stage6IncClaimReduction")); assert!(verifier_source .source .contains("stage6.input.stage1.LookupOutput")); @@ -1650,10 +1650,10 @@ fn stage7_rust_targets_extract_and_compile() { assert!(verifier_source.source.contains("pub fn verify_stage7")); assert!(verifier_source .source - .contains("relation: Some(\"jolt.stage7.batched\")")); + .contains("relation: Some(Stage7RelationKind::Stage7Batched)")); assert!(verifier_source .source - .contains("jolt.stage7.hamming_weight_claim_reduction")); + .contains("Stage7RelationKind::Stage7HammingWeightClaimReduction")); assert!(verifier_source .source .contains("expected_hamming_weight_claim_reduction")); @@ -1717,7 +1717,9 @@ fn stage8_rust_targets_extract_and_compile() { assert!(prover_source .source .contains("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0")); - assert!(verifier_source.source.contains("mode: \"verify\"")); + assert!(verifier_source + .source + .contains("mode: Stage8PcsProofMode::Verify")); assert_rust_source_compiles(&prover_source.filename, &prover_source.source); assert_rust_source_compiles(&verifier_source.filename, &verifier_source.source); } diff --git a/crates/jolt-prover/src/prover.rs b/crates/jolt-prover/src/prover.rs index 1907d74906..b0e33595f4 100644 --- a/crates/jolt-prover/src/prover.rs +++ b/crates/jolt-prover/src/prover.rs @@ -8,7 +8,7 @@ use jolt_field::Fr; use jolt_kernels::{stage1, stage2, stage3, stage4, stage5, stage6, stage7}; use jolt_openings::CommitmentScheme; use jolt_poly::{EqPolynomial, Polynomial}; -use jolt_transcript::{AppendToTranscript, Blake2bTranscript, LabelWithCount, Transcript}; +use jolt_transcript::{Blake2bTranscript, Transcript}; use jolt_verifier::{JoltEvaluationProof, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput}; use jolt_witness::{stage4_ram_val_init_opening, CycleInput, Stage45SparseTraceWitness, Stage6BytecodeEntry as WitnessStage6BytecodeEntry, Stage6WitnessParams, Stage6WitnessPolynomials, Stage6WitnessSlices}; use rayon::prelude::*; @@ -268,6 +268,61 @@ where Ok((proof, artifacts)) } +impl stage8_stage::Stage8NamedEvalView for stage7::Stage7NamedEval { + fn name(&self) -> &'static str { + self.name + } + + fn value(&self) -> Fr { + self.value + } +} + +impl stage8_stage::Stage8SumcheckOutputView + for stage7::Stage7SumcheckOutput +{ + type Eval = stage7::Stage7NamedEval; + + fn point(&self) -> &[Fr] { + &self.point + } + + fn evals(&self) -> &[Self::Eval] { + &self.evals + } +} + +impl stage8_stage::Stage8OpeningInputView + for stage7::Stage7OpeningInputValue +{ + fn symbol(&self) -> &'static str { + self.symbol + } + + fn point(&self) -> &[Fr] { + &self.point + } +} + +impl From for JoltEvaluationProveError { + fn from(error: stage8_stage::Stage8EvaluationOpeningPointError) -> Self { + match error { + stage8_stage::Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint => { + Self::MissingStage7EvaluationPoint + } + stage8_stage::Stage8EvaluationOpeningPointError::InvalidPointLength { + artifact, + expected, + actual, + } => Self::InvalidPointLength { + artifact, + expected, + actual, + }, + } + } +} + pub fn prove_jolt_evaluation_proof( program: &'static stage8_stage::Stage8EvaluationProgramPlan, commitment_inputs: &mut I, @@ -283,17 +338,24 @@ where T: Transcript, { let _claims_span = tracing::info_span!("bolt.evaluate.claims").entered(); - let (sumcheck_address_point, stage7_values) = stage7_claim_values(program, stage7)?; - let address_point = reverse_point(&sumcheck_address_point); + let (sumcheck_address_point, stage7_values) = + stage8_stage::stage7_claim_values(program, &stage7.sumchecks) + .ok_or(JoltEvaluationProveError::MissingStage7RaEval)?; + let address_point = stage8_stage::reverse_point(&sumcheck_address_point); let (opening_point, log_t) = - stage7_evaluation_opening_point(program, &address_point, stage7_openings)?; + stage8_stage::stage7_evaluation_opening_point(program, &address_point, stage7_openings)?; let lagrange_factor = EqPolynomial::::zero_selector(&address_point); - let claims = evaluation_claims(program, stage6, &stage7_values, lagrange_factor)?; + let claims = + stage8_stage::evaluation_claims(program, &stage6.sumchecks, &stage7_values, lagrange_factor) + .map_err(|error| JoltEvaluationProveError::MissingStageEval { + stage: error.stage, + eval: error.eval, + })?; drop(_claims_span); let _rlc_span = tracing::info_span!("bolt.evaluate.rlc_claims").entered(); - append_rlc_claims(transcript, &claims); - let gamma_powers = gamma_powers(transcript, claims.len()); + stage8_stage::append_rlc_claims(transcript, &claims); + let gamma_powers = stage8_stage::gamma_powers(transcript, claims.len()); let joint_claim = claims .iter() .zip(&gamma_powers) @@ -334,137 +396,9 @@ where Ok(JoltEvaluationProof { joint_opening_proof }) } -struct EvaluationClaim { - oracle: &'static str, - source_stage: &'static str, - value: Fr, -} - -fn stage6_eval_claim( - artifacts: &stage6::Stage6ExecutionArtifacts, - eval_name: &'static str, -) -> Result { - for output in &artifacts.sumchecks { - if let Some(eval) = output.evals.iter().find(|eval| eval.name == eval_name) { - return Ok(eval.value); - } - } - Err(JoltEvaluationProveError::MissingStageEval { - stage: "stage6", - eval: eval_name, - }) -} - -fn evaluation_claims( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - stage6: &stage6::Stage6ExecutionArtifacts, - stage7_values: &std::collections::BTreeMap<&'static str, Fr>, - lagrange_factor: Fr, -) -> Result, JoltEvaluationProveError> { - let mut claims = Vec::with_capacity(program.opening_claims.len()); - for plan in program.opening_claims { - let value = match plan.source_stage { - "stage6" => stage6_eval_claim(stage6, plan.source_claim)? * lagrange_factor, - "stage7" => *stage7_values.get(plan.source_claim).ok_or( - JoltEvaluationProveError::MissingStageEval { - stage: plan.source_stage, - eval: plan.source_claim, - }, - )?, - _ => { - return Err(JoltEvaluationProveError::MissingStageEval { - stage: plan.source_stage, - eval: plan.source_claim, - }); - } - }; - claims.push(EvaluationClaim { - oracle: plan.oracle, - source_stage: plan.source_stage, - value, - }); - } - Ok(claims) -} - -fn stage7_claim_values( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - artifacts: &stage7::Stage7ExecutionArtifacts, -) -> Result<(Vec, std::collections::BTreeMap<&'static str, Fr>), JoltEvaluationProveError> { - let stage7_plans = program - .opening_claims - .iter() - .filter(|plan| plan.source_stage == "stage7") - .collect::>(); - for output in &artifacts.sumchecks { - let mut values = std::collections::BTreeMap::new(); - for plan in &stage7_plans { - if let Some(eval) = output.evals.iter().find(|eval| eval.name == plan.source_claim) { - let _ = values.insert(plan.source_claim, eval.value); - } - } - if values.len() == stage7_plans.len() { - return Ok((output.point.clone(), values)); - } - } - Err(JoltEvaluationProveError::MissingStage7RaEval) -} - -fn reverse_point(point: &[Fr]) -> Vec { - point.iter().rev().copied().collect() -} - -fn stage7_evaluation_opening_point( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - address_point: &[Fr], - stage7_openings: &[stage7::Stage7OpeningInputValue], -) -> Result<(Vec, usize), JoltEvaluationProveError> { - let cycle_source_symbol = program.evaluation_point_source.source_claim; - let cycle_source = stage7_openings - .iter() - .find(|input| input.symbol == cycle_source_symbol) - .ok_or(JoltEvaluationProveError::MissingStage7EvaluationPoint)?; - if cycle_source.point.len() < address_point.len() { - return Err(JoltEvaluationProveError::InvalidPointLength { - artifact: cycle_source_symbol, - expected: address_point.len(), - actual: cycle_source.point.len(), - }); - } - let cycle_len = cycle_source.point.len() - address_point.len(); - let mut point = Vec::with_capacity(cycle_source.point.len()); - point.extend_from_slice(address_point); - point.extend_from_slice(&cycle_source.point[address_point.len()..]); - Ok((point, cycle_len)) -} - -fn append_rlc_claims(transcript: &mut T, claims: &[EvaluationClaim]) -where - T: Transcript, -{ - transcript.append(&LabelWithCount(b"rlc_claims", claims.len() as u64)); - for claim in claims { - claim.value.append_to_transcript(transcript); - } -} - -fn gamma_powers(transcript: &mut T, count: usize) -> Vec -where - T: Transcript, -{ - let gamma = transcript.challenge(); - let mut powers = Vec::with_capacity(count); - let mut power = Fr::from_u64(1); - for _ in 0..count { - powers.push(power); - power *= gamma; - } - powers -} - fn materialize_joint_polynomial( commitment_inputs: &mut I, - claims: &[EvaluationClaim], + claims: &[stage8_stage::Stage8EvaluationClaim], gamma_powers: &[Fr], log_t: usize, main_num_vars: usize, @@ -476,7 +410,7 @@ where let main_len = target_len(main_num_vars)?; let mut joint = vec![Fr::from_u64(0); main_len]; for (claim, gamma) in claims.iter().zip(gamma_powers) { - if claim.source_stage == "stage6" { + if claim.source_stage == stage8_stage::Stage8SourceStage::Stage6 { add_oracle_scaled(commitment_inputs, &mut joint, claim.oracle, log_t, trace_len, *gamma)?; } else { add_oracle_scaled( @@ -551,7 +485,7 @@ where fn joint_opening_hint( commitments: &commitment_stage::CommitmentArtifacts, - claims: &[EvaluationClaim], + claims: &[stage8_stage::Stage8EvaluationClaim], gamma_powers: &[Fr], ) -> Result { let mut coefficients = std::collections::BTreeMap::<&'static str, Fr>::new(); diff --git a/crates/jolt-prover/src/stages/commitment.rs b/crates/jolt-prover/src/stages/commitment.rs index eb744d8c88..50027da647 100644 --- a/crates/jolt-prover/src/stages/commitment.rs +++ b/crates/jolt-prover/src/stages/commitment.rs @@ -798,46 +798,11 @@ pub const ORACLE_PLANS: &[OraclePlan] = &[ OraclePlan { oracle: "TrustedAdvice", domain: "jolt.trace_domain", num_vars: 16 }, ]; pub const COMMITMENT_BATCH_0_ORACLES: &[&str] = &[ - "RdInc", - "RamInc", - "InstructionRa_0", - "InstructionRa_1", - "InstructionRa_2", - "InstructionRa_3", - "InstructionRa_4", - "InstructionRa_5", - "InstructionRa_6", - "InstructionRa_7", - "InstructionRa_8", - "InstructionRa_9", - "InstructionRa_10", - "InstructionRa_11", - "InstructionRa_12", - "InstructionRa_13", - "InstructionRa_14", - "InstructionRa_15", - "InstructionRa_16", - "InstructionRa_17", - "InstructionRa_18", - "InstructionRa_19", - "InstructionRa_20", - "InstructionRa_21", - "InstructionRa_22", - "InstructionRa_23", - "InstructionRa_24", - "InstructionRa_25", - "InstructionRa_26", - "InstructionRa_27", - "InstructionRa_28", - "InstructionRa_29", - "InstructionRa_30", - "InstructionRa_31", - "RamRa_0", - "RamRa_1", - "RamRa_2", - "RamRa_3", - "BytecodeRa_0", - "BytecodeRa_1", + "RdInc", "RamInc", "InstructionRa_0", "InstructionRa_1", "InstructionRa_2", "InstructionRa_3", "InstructionRa_4", "InstructionRa_5", + "InstructionRa_6", "InstructionRa_7", "InstructionRa_8", "InstructionRa_9", "InstructionRa_10", "InstructionRa_11", "InstructionRa_12", "InstructionRa_13", + "InstructionRa_14", "InstructionRa_15", "InstructionRa_16", "InstructionRa_17", "InstructionRa_18", "InstructionRa_19", "InstructionRa_20", "InstructionRa_21", + "InstructionRa_22", "InstructionRa_23", "InstructionRa_24", "InstructionRa_25", "InstructionRa_26", "InstructionRa_27", "InstructionRa_28", "InstructionRa_29", + "InstructionRa_30", "InstructionRa_31", "RamRa_0", "RamRa_1", "RamRa_2", "RamRa_3", "BytecodeRa_0", "BytecodeRa_1", "BytecodeRa_2", ]; pub const COMMITMENT_BATCH_PLANS: &[CommitmentBatchPlan] = &[ diff --git a/crates/jolt-prover/src/stages/stage1_outer.rs b/crates/jolt-prover/src/stages/stage1_outer.rs index e31d49a81e..a5f2b9ea7e 100644 --- a/crates/jolt-prover/src/stages/stage1_outer.rs +++ b/crates/jolt-prover/src/stages/stage1_outer.rs @@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript}; pub type DefaultStage1Transcript = Blake2bTranscript; -pub const STAGE1_PARAMS: Stage1Params = Stage1Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE1_PARAMS: Stage1Params = Stage1Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE1_TRANSCRIPT_SQUEEZES: &[Stage1TranscriptSqueezePlan] = &[ Stage1TranscriptSqueezePlan { symbol: "stage1.tau", label: "outer_tau", kind: "challenge_vector", count: 18 }, ]; @@ -32,29 +28,21 @@ pub const STAGE1_SUMCHECK_BATCH_0_ORDERED_CLAIMS: &[&str] = &["stage1.uniskip.in pub const STAGE1_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &["stage1.uniskip.input"]; -pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 1, -]; +pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1]; pub const STAGE1_SUMCHECK_BATCH_1_ORDERED_CLAIMS: &[&str] = &["stage1.outer_remaining.input"]; pub const STAGE1_SUMCHECK_BATCH_1_CLAIM_OPERANDS: &[&str] = &["stage1.outer_remaining.input"]; -pub const STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[ - 17, -]; +pub const STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[17]; pub const STAGE1_SUMCHECK_BATCHES: &[Stage1SumcheckBatchPlan] = &[ Stage1SumcheckBatchPlan { symbol: "stage1.uniskip.batch", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: STAGE1_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE1_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, Stage1SumcheckBatchPlan { symbol: "stage1.outer_remaining.batch", stage: "stage1", proof_slot: "stage1.sumcheck", policy: "jolt_core_front_loaded", count: 1, ordered_claims: STAGE1_SUMCHECK_BATCH_1_ORDERED_CLAIMS, claim_operands: STAGE1_SUMCHECK_BATCH_1_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, ]; -pub const STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 1, -]; +pub const STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1]; -pub const STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[ - 17, -]; +pub const STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[17]; pub const STAGE1_SUMCHECK_DRIVERS: &[Stage1SumcheckDriverPlan] = &[ Stage1SumcheckDriverPlan { symbol: "stage1.uniskip.sumcheck", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", kernel: Some("jolt.cpu.stage1.outer.uniskip"), relation: None, batch: "stage1.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 27 }, diff --git a/crates/jolt-prover/src/stages/stage2.rs b/crates/jolt-prover/src/stages/stage2.rs index ece68d1c0b..a5a5deed8d 100644 --- a/crates/jolt-prover/src/stages/stage2.rs +++ b/crates/jolt-prover/src/stages/stage2.rs @@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript}; pub type DefaultStage2Transcript = Blake2bTranscript; -pub const STAGE2_PARAMS: Stage2Params = Stage2Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE2_PARAMS: Stage2Params = Stage2Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE2_PROGRAM_STEPS: &[Stage2ProgramStepPlan] = &[ Stage2ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage2.product_virtual.tau_high" }, Stage2ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage2.product_virtual.uniskip.sumcheck" }, @@ -207,9 +203,7 @@ pub const STAGE2_SUMCHECK_BATCH_0_ORDERED_CLAIMS: &[&str] = &["stage2.product_vi pub const STAGE2_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &["stage2.product_virtual.uniskip.input"]; -pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 1, -]; +pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1]; pub const STAGE2_SUMCHECK_BATCH_1_ORDERED_CLAIMS: &[&str] = &[ "stage2.ram_read_write.input", @@ -227,23 +221,15 @@ pub const STAGE2_SUMCHECK_BATCH_1_CLAIM_OPERANDS: &[&str] = &[ "stage2.ram_output.input", ]; -pub const STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[ - 16, - 16, -]; +pub const STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[16, 16]; pub const STAGE2_SUMCHECK_BATCHES: &[Stage2SumcheckBatchPlan] = &[ Stage2SumcheckBatchPlan { symbol: "stage2.product_virtual.uniskip.batch", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: STAGE2_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE2_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, Stage2SumcheckBatchPlan { symbol: "stage2.batch", stage: "stage2", proof_slot: "stage2.sumcheck", policy: "jolt_core_stage2_aligned", count: 5, ordered_claims: STAGE2_SUMCHECK_BATCH_1_ORDERED_CLAIMS, claim_operands: STAGE2_SUMCHECK_BATCH_1_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, ]; -pub const STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 1, -]; +pub const STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1]; -pub const STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[ - 16, - 16, -]; +pub const STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[16, 16]; pub const STAGE2_SUMCHECK_DRIVERS: &[Stage2SumcheckDriverPlan] = &[ Stage2SumcheckDriverPlan { symbol: "stage2.product_virtual.uniskip.sumcheck", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", kernel: Some("jolt.cpu.stage2.product_virtual.uniskip"), relation: None, batch: "stage2.product_virtual.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 6 }, diff --git a/crates/jolt-prover/src/stages/stage3.rs b/crates/jolt-prover/src/stages/stage3.rs index f1ca47494b..6a4dab2e86 100644 --- a/crates/jolt-prover/src/stages/stage3.rs +++ b/crates/jolt-prover/src/stages/stage3.rs @@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript}; pub type DefaultStage3Transcript = Blake2bTranscript; -pub const STAGE3_PARAMS: Stage3Params = Stage3Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE3_PARAMS: Stage3Params = Stage3Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[ Stage3ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage3.spartan_shift.gamma" }, Stage3ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage3.instruction_input.gamma" }, @@ -196,16 +192,12 @@ pub const STAGE3_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &[ "stage3.registers_claim_reduction.input", ]; -pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 16, -]; +pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16]; pub const STAGE3_SUMCHECK_BATCHES: &[Stage3SumcheckBatchPlan] = &[ Stage3SumcheckBatchPlan { symbol: "stage3.batch", stage: "stage3", proof_slot: "stage3.sumcheck", policy: "jolt_core_stage3_aligned", count: 3, ordered_claims: STAGE3_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE3_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; -pub const STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 16, -]; +pub const STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16]; pub const STAGE3_SUMCHECK_DRIVERS: &[Stage3SumcheckDriverPlan] = &[ Stage3SumcheckDriverPlan { symbol: "stage3.sumcheck", stage: "stage3", proof_slot: "stage3.sumcheck", kernel: Some("jolt.cpu.stage3.batched"), relation: None, batch: "stage3.batch", policy: "jolt_core_stage3_aligned", round_schedule: STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 16, degree: 3 }, diff --git a/crates/jolt-prover/src/stages/stage4.rs b/crates/jolt-prover/src/stages/stage4.rs index 03a8258a94..db47762400 100644 --- a/crates/jolt-prover/src/stages/stage4.rs +++ b/crates/jolt-prover/src/stages/stage4.rs @@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript}; pub type DefaultStage4Transcript = Blake2bTranscript; -pub const STAGE4_PARAMS: Stage4Params = Stage4Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE4_PARAMS: Stage4Params = Stage4Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE4_PROGRAM_STEPS: &[Stage4ProgramStepPlan] = &[ Stage4ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage4.registers_read_write.gamma" }, Stage4ProgramStepPlan { kind: "transcript_absorb_bytes", symbol: "stage4.ram_val_check.domain_separator" }, @@ -127,18 +123,12 @@ pub const STAGE4_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &[ "stage4.ram_val_check.input", ]; -pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 16, - 7, -]; +pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16, 7]; pub const STAGE4_SUMCHECK_BATCHES: &[Stage4SumcheckBatchPlan] = &[ Stage4SumcheckBatchPlan { symbol: "stage4.batch", stage: "stage4", proof_slot: "stage4.sumcheck", policy: "jolt_core_stage4_aligned", count: 2, ordered_claims: STAGE4_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE4_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; -pub const STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 16, - 7, -]; +pub const STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16, 7]; pub const STAGE4_SUMCHECK_DRIVERS: &[Stage4SumcheckDriverPlan] = &[ Stage4SumcheckDriverPlan { symbol: "stage4.sumcheck", stage: "stage4", proof_slot: "stage4.sumcheck", kernel: Some("jolt.cpu.stage4.batched"), relation: None, batch: "stage4.batch", policy: "jolt_core_stage4_aligned", round_schedule: STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 23, degree: 3 }, diff --git a/crates/jolt-prover/src/stages/stage5.rs b/crates/jolt-prover/src/stages/stage5.rs index 22604c721f..f1ccc4a3f1 100644 --- a/crates/jolt-prover/src/stages/stage5.rs +++ b/crates/jolt-prover/src/stages/stage5.rs @@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript}; pub type DefaultStage5Transcript = Blake2bTranscript; -pub const STAGE5_PARAMS: Stage5Params = Stage5Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE5_PARAMS: Stage5Params = Stage5Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE5_PROGRAM_STEPS: &[Stage5ProgramStepPlan] = &[ Stage5ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage5.instruction_read_raf.gamma" }, Stage5ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage5.ram_ra_claim_reduction.gamma" }, @@ -135,18 +131,12 @@ pub const STAGE5_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &[ "stage5.registers_val_evaluation.input", ]; -pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 128, - 16, -]; +pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[128, 16]; pub const STAGE5_SUMCHECK_BATCHES: &[Stage5SumcheckBatchPlan] = &[ Stage5SumcheckBatchPlan { symbol: "stage5.batch", stage: "stage5", proof_slot: "stage5.sumcheck", policy: "jolt_core_stage5_aligned", count: 3, ordered_claims: STAGE5_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE5_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; -pub const STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 128, - 16, -]; +pub const STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[128, 16]; pub const STAGE5_SUMCHECK_DRIVERS: &[Stage5SumcheckDriverPlan] = &[ Stage5SumcheckDriverPlan { symbol: "stage5.sumcheck", stage: "stage5", proof_slot: "stage5.sumcheck", kernel: Some("jolt.cpu.stage5.batched"), relation: None, batch: "stage5.batch", policy: "jolt_core_stage5_aligned", round_schedule: STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 144, degree: 10 }, diff --git a/crates/jolt-prover/src/stages/stage6.rs b/crates/jolt-prover/src/stages/stage6.rs index ad59b1a999..cdb6e9601f 100644 --- a/crates/jolt-prover/src/stages/stage6.rs +++ b/crates/jolt-prover/src/stages/stage6.rs @@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript}; pub type DefaultStage6Transcript = Blake2bTranscript; -pub const STAGE6_PARAMS: Stage6Params = Stage6Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE6_PARAMS: Stage6Params = Stage6Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE6_PROGRAM_STEPS: &[Stage6ProgramStepPlan] = &[ Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.gamma" }, Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage1_gamma" }, @@ -1886,18 +1882,12 @@ pub const STAGE6_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &[ "stage6.inc_claim_reduction.input", ]; -pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 10, - 16, -]; +pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[10, 16]; pub const STAGE6_SUMCHECK_BATCHES: &[Stage6SumcheckBatchPlan] = &[ Stage6SumcheckBatchPlan { symbol: "stage6.batch", stage: "stage6", proof_slot: "stage6.sumcheck", policy: "jolt_core_stage6_aligned", count: 6, ordered_claims: STAGE6_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE6_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; -pub const STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 10, - 16, -]; +pub const STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[10, 16]; pub const STAGE6_SUMCHECK_DRIVERS: &[Stage6SumcheckDriverPlan] = &[ Stage6SumcheckDriverPlan { symbol: "stage6.sumcheck", stage: "stage6", proof_slot: "stage6.sumcheck", kernel: Some("jolt.cpu.stage6.batched"), relation: None, batch: "stage6.batch", policy: "jolt_core_stage6_aligned", round_schedule: STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 26, degree: 5 }, diff --git a/crates/jolt-prover/src/stages/stage7.rs b/crates/jolt-prover/src/stages/stage7.rs index 831534a4b9..fb8ecbebf5 100644 --- a/crates/jolt-prover/src/stages/stage7.rs +++ b/crates/jolt-prover/src/stages/stage7.rs @@ -6,11 +6,7 @@ use jolt_transcript::{Blake2bTranscript, Transcript}; pub type DefaultStage7Transcript = Blake2bTranscript; -pub const STAGE7_PARAMS: Stage7Params = Stage7Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE7_PARAMS: Stage7Params = Stage7Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE7_PROGRAM_STEPS: &[Stage7ProgramStepPlan] = &[ Stage7ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage7.hamming_weight_claim_reduction.gamma" }, Stage7ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage7.sumcheck" }, @@ -1716,16 +1712,12 @@ pub const STAGE7_SUMCHECK_BATCH_0_ORDERED_CLAIMS: &[&str] = &["stage7.hamming_we pub const STAGE7_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &["stage7.hamming_weight_claim_reduction.input"]; -pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 4, -]; +pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[ Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, ordered_claims: STAGE7_SUMCHECK_BATCH_0_ORDERED_CLAIMS, claim_operands: STAGE7_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; -pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 4, -]; +pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_DRIVERS: &[Stage7SumcheckDriverPlan] = &[ Stage7SumcheckDriverPlan { symbol: "stage7.sumcheck", stage: "stage7", proof_slot: "stage7.sumcheck", kernel: Some("jolt.cpu.stage7.batched"), relation: None, batch: "stage7.batch", policy: "jolt_core_stage7_aligned", round_schedule: STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 4, degree: 2 }, diff --git a/crates/jolt-prover/src/stages/stage8.rs b/crates/jolt-prover/src/stages/stage8.rs index 632dbe3925..6726f6e596 100644 --- a/crates/jolt-prover/src/stages/stage8.rs +++ b/crates/jolt-prover/src/stages/stage8.rs @@ -7,47 +7,126 @@ pub struct Stage8Params { pub transcript: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage8ClaimKind { + Committed, + Virtual, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage8SourceStage { + Stage6, + Stage7, +} + +impl Stage8SourceStage { + pub fn as_str(self) -> &'static str { + match self { + Self::Stage6 => "stage6", + Self::Stage7 => "stage7", + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct Stage8OpeningInputSymbol(&'static str); + +impl Stage8OpeningInputSymbol { + pub const fn new(symbol: &'static str) -> Self { + Self(symbol) + } + + pub fn as_str(self) -> &'static str { + self.0 + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct Stage8OpeningClaimSymbol(&'static str); + +impl Stage8OpeningClaimSymbol { + pub const fn new(symbol: &'static str) -> Self { + Self(symbol) + } + + pub fn as_str(self) -> &'static str { + self.0 + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct Stage8OpeningBatchSymbol(&'static str); + +impl Stage8OpeningBatchSymbol { + pub const fn new(symbol: &'static str) -> Self { + Self(symbol) + } + + pub fn as_str(self) -> &'static str { + self.0 + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct Stage8SourceClaim(&'static str); + +impl Stage8SourceClaim { + pub const fn new(symbol: &'static str) -> Self { + Self(symbol) + } + + pub fn as_str(self) -> &'static str { + self.0 + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8OpeningInputPlan { - pub symbol: &'static str, - pub source_stage: &'static str, - pub source_claim: &'static str, + pub symbol: Stage8OpeningInputSymbol, + pub source_stage: Stage8SourceStage, + pub source_claim: Stage8SourceClaim, pub oracle: &'static str, pub domain: &'static str, pub point_arity: usize, - pub claim_kind: &'static str, + pub claim_kind: Stage8ClaimKind, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8OpeningClaimPlan { - pub symbol: &'static str, + pub symbol: Stage8OpeningClaimSymbol, pub oracle: &'static str, pub family: &'static str, pub domain: &'static str, pub point_arity: usize, - pub point_source: &'static str, - pub eval_source: &'static str, - pub source_stage: &'static str, - pub source_claim: &'static str, + pub point_source: Stage8OpeningInputSymbol, + pub eval_source: Stage8OpeningInputSymbol, + pub source_stage: Stage8SourceStage, + pub source_claim: Stage8SourceClaim, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8OpeningBatchPlan { - pub symbol: &'static str, + pub symbol: Stage8OpeningBatchSymbol, pub proof_slot: &'static str, pub policy: &'static str, pub count: usize, - pub ordered_claims: &'static [&'static str], + pub ordered_claims: &'static [Stage8OpeningClaimPlan], +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage8PcsProofMode { + Open, + Verify, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8PcsProofPlan { pub symbol: &'static str, - pub mode: &'static str, + pub mode: Stage8PcsProofMode, pub pcs: &'static str, pub proof_slot: &'static str, pub transcript_label: &'static str, - pub batch: &'static str, + pub batch: Stage8OpeningBatchSymbol, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -62,112 +141,294 @@ pub struct Stage8EvaluationProgramPlan { pub pcs_proof: Stage8PcsProofPlan, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage8EvaluationClaim { + pub oracle: &'static str, + pub source_stage: Stage8SourceStage, + pub value: F, +} + +pub fn reverse_point(point: &[F]) -> Vec { + point.iter().rev().copied().collect() +} + +pub fn append_rlc_claims(transcript: &mut T, claims: &[Stage8EvaluationClaim]) +where + F: jolt_field::Field + jolt_transcript::AppendToTranscript, + T: jolt_transcript::Transcript, +{ + transcript.append(&jolt_transcript::LabelWithCount( + b"rlc_claims", + claims.len() as u64, + )); + for claim in claims { + jolt_transcript::AppendToTranscript::append_to_transcript(&claim.value, transcript); + } +} + +pub fn gamma_powers(transcript: &mut T, count: usize) -> Vec +where + F: jolt_field::Field, + T: jolt_transcript::Transcript, +{ + let gamma = transcript.challenge(); + let mut powers = Vec::with_capacity(count); + let mut power = F::from_u64(1); + for _ in 0..count { + powers.push(power); + power *= gamma; + } + powers +} + +pub trait Stage8NamedEvalView { + fn name(&self) -> &'static str; + fn value(&self) -> F; +} + +pub trait Stage8SumcheckOutputView { + type Eval: Stage8NamedEvalView; + + fn point(&self) -> &[F]; + fn evals(&self) -> &[Self::Eval]; +} + +pub fn stage7_claim_values( + program: &'static Stage8EvaluationProgramPlan, + outputs: &[O], +) -> Option<(Vec, std::collections::BTreeMap)> +where + F: Copy, + O: Stage8SumcheckOutputView, +{ + let stage7_plans = program + .opening_claims + .iter() + .filter(|plan| plan.source_stage == Stage8SourceStage::Stage7) + .collect::>(); + for output in outputs { + let mut values = std::collections::BTreeMap::new(); + for plan in &stage7_plans { + if let Some(eval) = output + .evals() + .iter() + .find(|eval| eval.name() == plan.source_claim.as_str()) + { + let _ = values.insert(plan.source_claim, eval.value()); + } + } + if values.len() == stage7_plans.len() { + return Some((output.point().to_vec(), values)); + } + } + None +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage8EvaluationClaimError { + pub stage: &'static str, + pub eval: &'static str, +} + +pub fn evaluation_claims( + program: &'static Stage8EvaluationProgramPlan, + stage6_outputs: &[O], + stage7_values: &std::collections::BTreeMap, + lagrange_factor: F, +) -> Result>, Stage8EvaluationClaimError> +where + F: Copy + std::ops::Mul, + O: Stage8SumcheckOutputView, +{ + let mut claims = Vec::with_capacity(program.opening_claims.len()); + for plan in program.opening_claims { + let value = match plan.source_stage { + Stage8SourceStage::Stage6 => { + stage_eval(stage6_outputs, plan.source_stage.as_str(), plan.source_claim)? + * lagrange_factor + } + Stage8SourceStage::Stage7 => *stage7_values.get(&plan.source_claim).ok_or( + Stage8EvaluationClaimError { + stage: plan.source_stage.as_str(), + eval: plan.source_claim.as_str(), + }, + )?, + }; + claims.push(Stage8EvaluationClaim { + oracle: plan.oracle, + source_stage: plan.source_stage, + value, + }); + } + Ok(claims) +} + +fn stage_eval( + outputs: &[O], + stage: &'static str, + eval_name: Stage8SourceClaim, +) -> Result +where + F: Copy, + O: Stage8SumcheckOutputView, +{ + for output in outputs { + let eval = output + .evals() + .iter() + .find(|eval| eval.name() == eval_name.as_str()); + if let Some(eval) = eval { return Ok(eval.value()); } + } + Err(Stage8EvaluationClaimError { + stage, + eval: eval_name.as_str(), + }) +} + +pub trait Stage8OpeningInputView { + fn symbol(&self) -> &'static str; + fn point(&self) -> &[F]; +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage8EvaluationOpeningPointError { + MissingStage7EvaluationPoint, + InvalidPointLength { + artifact: &'static str, + expected: usize, + actual: usize, + }, +} + +pub fn stage7_evaluation_opening_point( + program: &'static Stage8EvaluationProgramPlan, + address_point: &[F], + stage7_openings: &[I], +) -> Result<(Vec, usize), Stage8EvaluationOpeningPointError> +where + F: Copy, + I: Stage8OpeningInputView, +{ + let cycle_source_symbol = program.evaluation_point_source.source_claim; + let cycle_source = stage7_openings + .iter() + .find(|input| input.symbol() == cycle_source_symbol.as_str()) + .ok_or(Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint)?; + let cycle_source_point = cycle_source.point(); + if cycle_source_point.len() < address_point.len() { + return Err(Stage8EvaluationOpeningPointError::InvalidPointLength { + artifact: cycle_source_symbol.as_str(), + expected: address_point.len(), + actual: cycle_source_point.len(), + }); + } + let cycle_len = cycle_source_point.len() - address_point.len(); + let mut point = Vec::with_capacity(cycle_source_point.len()); + point.extend_from_slice(address_point); + point.extend_from_slice(&cycle_source_point[address_point.len()..]); + Ok((point, cycle_len)) +} + pub const STAGE8_PARAMS: Stage8Params = Stage8Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; -pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = Stage8OpeningInputPlan { symbol: "stage8.evaluation.point_source", source_stage: "stage7", source_claim: "stage7.input.stage6.booleanity.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }; +pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.evaluation.point_source"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.input.stage6.booleanity.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }; +#[rustfmt::skip] pub const STAGE8_OPENING_INPUTS: &[Stage8OpeningInputPlan] = &[ - Stage8OpeningInputPlan { symbol: "stage8.evaluation.point_source", source_stage: "stage7", source_claim: "stage7.input.stage6.booleanity.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage6.RamInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RamInc", oracle: "RamInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage6.RdInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RdInc", oracle: "RdInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_4", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_5", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_6", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_7", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_8", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_9", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_10", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_11", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_12", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_13", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_14", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_15", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_16", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_17", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_18", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_19", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_20", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_21", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_22", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_23", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_24", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_25", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_26", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_27", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_28", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_29", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_30", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_31", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.evaluation.point_source"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.input.stage6.booleanity.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RamInc"), oracle: "RamInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RdInc"), oracle: "RdInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1"), oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2"), oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3"), oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4"), oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5"), oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6"), oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7"), oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8"), oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9"), oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10"), oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11"), oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12"), oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13"), oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14"), oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15"), oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16"), oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17"), oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18"), oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19"), oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20"), oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21"), oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22"), oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23"), oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24"), oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25"), oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26"), oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27"), oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28"), oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29"), oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30"), oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31"), oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0"), oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1"), oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2"), oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_0"), oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_1"), oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_2"), oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_3"), oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, ]; +#[rustfmt::skip] pub const STAGE8_OPENING_CLAIMS: &[Stage8OpeningClaimPlan] = &[ - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamInc", oracle: "RamInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage6.RamInc", eval_source: "stage8.input.stage6.RamInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RamInc" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RdInc", oracle: "RdInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage6.RdInc", eval_source: "stage8.input.stage6.RdInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RdInc" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_0", oracle: "InstructionRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_0", eval_source: "stage8.input.stage7.InstructionRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_1", oracle: "InstructionRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_1", eval_source: "stage8.input.stage7.InstructionRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_2", oracle: "InstructionRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_2", eval_source: "stage8.input.stage7.InstructionRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_3", oracle: "InstructionRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_3", eval_source: "stage8.input.stage7.InstructionRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_4", oracle: "InstructionRa_4", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_4", eval_source: "stage8.input.stage7.InstructionRa_4", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_5", oracle: "InstructionRa_5", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_5", eval_source: "stage8.input.stage7.InstructionRa_5", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_6", oracle: "InstructionRa_6", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_6", eval_source: "stage8.input.stage7.InstructionRa_6", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_7", oracle: "InstructionRa_7", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_7", eval_source: "stage8.input.stage7.InstructionRa_7", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_8", oracle: "InstructionRa_8", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_8", eval_source: "stage8.input.stage7.InstructionRa_8", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_9", oracle: "InstructionRa_9", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_9", eval_source: "stage8.input.stage7.InstructionRa_9", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_10", oracle: "InstructionRa_10", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_10", eval_source: "stage8.input.stage7.InstructionRa_10", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_11", oracle: "InstructionRa_11", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_11", eval_source: "stage8.input.stage7.InstructionRa_11", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_12", oracle: "InstructionRa_12", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_12", eval_source: "stage8.input.stage7.InstructionRa_12", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_13", oracle: "InstructionRa_13", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_13", eval_source: "stage8.input.stage7.InstructionRa_13", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_14", oracle: "InstructionRa_14", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_14", eval_source: "stage8.input.stage7.InstructionRa_14", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_15", oracle: "InstructionRa_15", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_15", eval_source: "stage8.input.stage7.InstructionRa_15", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_16", oracle: "InstructionRa_16", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_16", eval_source: "stage8.input.stage7.InstructionRa_16", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_17", oracle: "InstructionRa_17", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_17", eval_source: "stage8.input.stage7.InstructionRa_17", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_18", oracle: "InstructionRa_18", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_18", eval_source: "stage8.input.stage7.InstructionRa_18", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_19", oracle: "InstructionRa_19", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_19", eval_source: "stage8.input.stage7.InstructionRa_19", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_20", oracle: "InstructionRa_20", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_20", eval_source: "stage8.input.stage7.InstructionRa_20", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_21", oracle: "InstructionRa_21", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_21", eval_source: "stage8.input.stage7.InstructionRa_21", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_22", oracle: "InstructionRa_22", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_22", eval_source: "stage8.input.stage7.InstructionRa_22", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_23", oracle: "InstructionRa_23", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_23", eval_source: "stage8.input.stage7.InstructionRa_23", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_24", oracle: "InstructionRa_24", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_24", eval_source: "stage8.input.stage7.InstructionRa_24", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_25", oracle: "InstructionRa_25", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_25", eval_source: "stage8.input.stage7.InstructionRa_25", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_26", oracle: "InstructionRa_26", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_26", eval_source: "stage8.input.stage7.InstructionRa_26", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_27", oracle: "InstructionRa_27", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_27", eval_source: "stage8.input.stage7.InstructionRa_27", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_28", oracle: "InstructionRa_28", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_28", eval_source: "stage8.input.stage7.InstructionRa_28", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_29", oracle: "InstructionRa_29", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_29", eval_source: "stage8.input.stage7.InstructionRa_29", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_30", oracle: "InstructionRa_30", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_30", eval_source: "stage8.input.stage7.InstructionRa_30", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_31", oracle: "InstructionRa_31", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_31", eval_source: "stage8.input.stage7.InstructionRa_31", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_0", oracle: "BytecodeRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_0", eval_source: "stage8.input.stage7.BytecodeRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_1", oracle: "BytecodeRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_1", eval_source: "stage8.input.stage7.BytecodeRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_2", oracle: "BytecodeRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_2", eval_source: "stage8.input.stage7.BytecodeRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_0", oracle: "RamRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_0", eval_source: "stage8.input.stage7.RamRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_0" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_1", oracle: "RamRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_1", eval_source: "stage8.input.stage7.RamRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_1" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_2", oracle: "RamRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_2", eval_source: "stage8.input.stage7.RamRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_2" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_3", oracle: "RamRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_3", eval_source: "stage8.input.stage7.RamRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_3" }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamInc"), oracle: "RamInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RamInc") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RdInc"), oracle: "RdInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RdInc") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_0"), oracle: "InstructionRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_1"), oracle: "InstructionRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_2"), oracle: "InstructionRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_3"), oracle: "InstructionRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_4"), oracle: "InstructionRa_4", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_5"), oracle: "InstructionRa_5", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_6"), oracle: "InstructionRa_6", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_7"), oracle: "InstructionRa_7", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_8"), oracle: "InstructionRa_8", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_9"), oracle: "InstructionRa_9", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_10"), oracle: "InstructionRa_10", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_11"), oracle: "InstructionRa_11", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_12"), oracle: "InstructionRa_12", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_13"), oracle: "InstructionRa_13", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_14"), oracle: "InstructionRa_14", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_15"), oracle: "InstructionRa_15", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_16"), oracle: "InstructionRa_16", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_17"), oracle: "InstructionRa_17", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_18"), oracle: "InstructionRa_18", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_19"), oracle: "InstructionRa_19", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_20"), oracle: "InstructionRa_20", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_21"), oracle: "InstructionRa_21", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_22"), oracle: "InstructionRa_22", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_23"), oracle: "InstructionRa_23", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_24"), oracle: "InstructionRa_24", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_25"), oracle: "InstructionRa_25", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_26"), oracle: "InstructionRa_26", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_27"), oracle: "InstructionRa_27", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_28"), oracle: "InstructionRa_28", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_29"), oracle: "InstructionRa_29", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_30"), oracle: "InstructionRa_30", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_31"), oracle: "InstructionRa_31", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_0"), oracle: "BytecodeRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_1"), oracle: "BytecodeRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_2"), oracle: "BytecodeRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_0"), oracle: "RamRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_0") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_1"), oracle: "RamRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_1") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_2"), oracle: "RamRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_2") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_3"), oracle: "RamRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_3") }, ]; -pub const STAGE8_OPENING_BATCH_ORDERED_CLAIMS: &[&str] = &["stage8.evaluation.opening.RamInc", "stage8.evaluation.opening.RdInc", "stage8.evaluation.opening.InstructionRa_0", "stage8.evaluation.opening.InstructionRa_1", "stage8.evaluation.opening.InstructionRa_2", "stage8.evaluation.opening.InstructionRa_3", "stage8.evaluation.opening.InstructionRa_4", "stage8.evaluation.opening.InstructionRa_5", "stage8.evaluation.opening.InstructionRa_6", "stage8.evaluation.opening.InstructionRa_7", "stage8.evaluation.opening.InstructionRa_8", "stage8.evaluation.opening.InstructionRa_9", "stage8.evaluation.opening.InstructionRa_10", "stage8.evaluation.opening.InstructionRa_11", "stage8.evaluation.opening.InstructionRa_12", "stage8.evaluation.opening.InstructionRa_13", "stage8.evaluation.opening.InstructionRa_14", "stage8.evaluation.opening.InstructionRa_15", "stage8.evaluation.opening.InstructionRa_16", "stage8.evaluation.opening.InstructionRa_17", "stage8.evaluation.opening.InstructionRa_18", "stage8.evaluation.opening.InstructionRa_19", "stage8.evaluation.opening.InstructionRa_20", "stage8.evaluation.opening.InstructionRa_21", "stage8.evaluation.opening.InstructionRa_22", "stage8.evaluation.opening.InstructionRa_23", "stage8.evaluation.opening.InstructionRa_24", "stage8.evaluation.opening.InstructionRa_25", "stage8.evaluation.opening.InstructionRa_26", "stage8.evaluation.opening.InstructionRa_27", "stage8.evaluation.opening.InstructionRa_28", "stage8.evaluation.opening.InstructionRa_29", "stage8.evaluation.opening.InstructionRa_30", "stage8.evaluation.opening.InstructionRa_31", "stage8.evaluation.opening.BytecodeRa_0", "stage8.evaluation.opening.BytecodeRa_1", "stage8.evaluation.opening.BytecodeRa_2", "stage8.evaluation.opening.RamRa_0", "stage8.evaluation.opening.RamRa_1", "stage8.evaluation.opening.RamRa_2", "stage8.evaluation.opening.RamRa_3"]; - -pub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = Stage8OpeningBatchPlan { symbol: "stage8.evaluation.openings", proof_slot: "stage8.evaluation", policy: "jolt_stage8_joint_rlc", count: 41, ordered_claims: STAGE8_OPENING_BATCH_ORDERED_CLAIMS }; +#[rustfmt::skip] +pub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = Stage8OpeningBatchPlan { symbol: Stage8OpeningBatchSymbol::new("stage8.evaluation.openings"), proof_slot: "stage8.evaluation", policy: "jolt_stage8_joint_rlc", count: 41, ordered_claims: STAGE8_OPENING_CLAIMS }; -pub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = Stage8PcsProofPlan { symbol: "stage8.evaluation.proof", mode: "open", pcs: "dory", proof_slot: "stage8.evaluation", transcript_label: "rlc_claims", batch: "stage8.evaluation.openings" }; +#[rustfmt::skip] +pub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = Stage8PcsProofPlan { symbol: "stage8.evaluation.proof", mode: Stage8PcsProofMode::Open, pcs: "dory", proof_slot: "stage8.evaluation", transcript_label: "rlc_claims", batch: Stage8OpeningBatchSymbol::new("stage8.evaluation.openings") }; -pub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan { - role: "prover", - function: "jolt.stage8", - params: STAGE8_PARAMS, - evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE, - opening_inputs: STAGE8_OPENING_INPUTS, - opening_claims: STAGE8_OPENING_CLAIMS, - opening_batch: STAGE8_OPENING_BATCH, - pcs_proof: STAGE8_PCS_PROOF, -}; +#[rustfmt::skip] +pub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan { role: "prover", function: "jolt.stage8", params: STAGE8_PARAMS, evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE, opening_inputs: STAGE8_OPENING_INPUTS, opening_claims: STAGE8_OPENING_CLAIMS, opening_batch: STAGE8_OPENING_BATCH, pcs_proof: STAGE8_PCS_PROOF }; diff --git a/crates/jolt-verifier/src/stages/commitment.rs b/crates/jolt-verifier/src/stages/commitment.rs index ea31591867..f38a8ef072 100644 --- a/crates/jolt-verifier/src/stages/commitment.rs +++ b/crates/jolt-verifier/src/stages/commitment.rs @@ -137,46 +137,11 @@ pub const ORACLE_PLANS: &[OraclePlan] = &[ OraclePlan { oracle: "TrustedAdvice", domain: "jolt.trace_domain", num_vars: 16 }, ]; pub const COMMITMENT_BATCH_0_ORACLES: &[&str] = &[ - "RdInc", - "RamInc", - "InstructionRa_0", - "InstructionRa_1", - "InstructionRa_2", - "InstructionRa_3", - "InstructionRa_4", - "InstructionRa_5", - "InstructionRa_6", - "InstructionRa_7", - "InstructionRa_8", - "InstructionRa_9", - "InstructionRa_10", - "InstructionRa_11", - "InstructionRa_12", - "InstructionRa_13", - "InstructionRa_14", - "InstructionRa_15", - "InstructionRa_16", - "InstructionRa_17", - "InstructionRa_18", - "InstructionRa_19", - "InstructionRa_20", - "InstructionRa_21", - "InstructionRa_22", - "InstructionRa_23", - "InstructionRa_24", - "InstructionRa_25", - "InstructionRa_26", - "InstructionRa_27", - "InstructionRa_28", - "InstructionRa_29", - "InstructionRa_30", - "InstructionRa_31", - "RamRa_0", - "RamRa_1", - "RamRa_2", - "RamRa_3", - "BytecodeRa_0", - "BytecodeRa_1", + "RdInc", "RamInc", "InstructionRa_0", "InstructionRa_1", "InstructionRa_2", "InstructionRa_3", "InstructionRa_4", "InstructionRa_5", + "InstructionRa_6", "InstructionRa_7", "InstructionRa_8", "InstructionRa_9", "InstructionRa_10", "InstructionRa_11", "InstructionRa_12", "InstructionRa_13", + "InstructionRa_14", "InstructionRa_15", "InstructionRa_16", "InstructionRa_17", "InstructionRa_18", "InstructionRa_19", "InstructionRa_20", "InstructionRa_21", + "InstructionRa_22", "InstructionRa_23", "InstructionRa_24", "InstructionRa_25", "InstructionRa_26", "InstructionRa_27", "InstructionRa_28", "InstructionRa_29", + "InstructionRa_30", "InstructionRa_31", "RamRa_0", "RamRa_1", "RamRa_2", "RamRa_3", "BytecodeRa_0", "BytecodeRa_1", "BytecodeRa_2", ]; pub const COMMITMENT_BATCH_PLANS: &[CommitmentBatchPlan] = &[ diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs index 493e9e9395..91b706f1dc 100644 --- a/crates/jolt-verifier/src/stages/common.rs +++ b/crates/jolt-verifier/src/stages/common.rs @@ -3,8 +3,12 @@ reason = "generated verifier helpers mirror staged protocol ABIs" )] +use std::cmp::Ordering; +use std::fmt; +use std::marker::PhantomData; + use jolt_field::{Field, Fr, MulPow2, RingCore}; -use jolt_poly::EqPolynomial; +use jolt_poly::{lagrange::lagrange_evals, EqPolynomial}; use jolt_sumcheck::{ CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier, }; @@ -18,6 +22,61 @@ pub struct StageParams { pub transcript: &'static str, } +pub struct TypedPlanSymbol { + symbol: &'static str, + _tag: PhantomData Tag>, +} + +impl TypedPlanSymbol { + pub(crate) const fn new(symbol: &'static str) -> Self { + Self { + symbol, + _tag: PhantomData, + } + } + + pub fn as_str(self) -> &'static str { + self.symbol + } +} + +impl Clone for TypedPlanSymbol { + fn clone(&self) -> Self { + *self + } +} + +impl Copy for TypedPlanSymbol {} + +impl fmt::Debug for TypedPlanSymbol { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter + .debug_tuple("TypedPlanSymbol") + .field(&self.symbol) + .finish() + } +} + +impl PartialEq for TypedPlanSymbol { + fn eq(&self, other: &Self) -> bool { + self.symbol == other.symbol + } +} + +impl Eq for TypedPlanSymbol {} + +impl PartialOrd for TypedPlanSymbol { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for TypedPlanSymbol { + fn cmp(&self, other: &Self) -> Ordering { + self.symbol.cmp(other.symbol) + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct KernelPlan { pub symbol: &'static str, @@ -27,11 +86,28 @@ pub struct KernelPlan { pub abi: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[rustfmt::skip] +pub enum RelationKind { Stage1OuterUniskip, Stage1OuterRemaining, Stage2ProductVirtualUniskip, Stage2RamReadWrite, Stage2ProductVirtualRemainder, Stage2InstructionLookupClaimReduction, Stage2RamRafEvaluation, Stage2RamOutputCheck, Stage2Batched, Stage3SpartanShift, Stage3InstructionInput, Stage3RegistersClaimReduction, Stage3Batched, Stage4RegistersReadWrite, Stage4RamValCheck, Stage4Batched, Stage5InstructionReadRaf, Stage5RamRaClaimReduction, Stage5RegistersValEvaluation, Stage5Batched, Stage6BytecodeReadRaf, Stage6Booleanity, Stage6HammingBooleanity, Stage6RamRaVirtual, Stage6InstructionRaVirtual, Stage6IncClaimReduction, Stage6Batched, Stage7HammingWeightClaimReduction, Stage7Batched } + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum TranscriptSqueezeKind { + ChallengeScalar, + ChallengeVector, + Scalar, +} + +impl TranscriptSqueezeKind { + pub fn is_scalar(self) -> bool { + matches!(self, Self::ChallengeScalar | Self::Scalar) + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct TranscriptSqueezePlan { pub symbol: &'static str, pub label: &'static str, - pub kind: &'static str, + pub kind: TranscriptSqueezeKind, pub count: usize, } @@ -42,12 +118,46 @@ pub struct TranscriptAbsorbBytesPlan { pub payload: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ProgramStepKind { + TranscriptSqueeze, + TranscriptAbsorbBytes, + SumcheckDriver, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct ProgramStepPlan { - pub kind: &'static str, + pub kind: ProgramStepKind, pub symbol: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ClaimKind { + Committed, + Virtual, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SourceStage { + Stage6, + Stage7, +} + +impl SourceStage { + pub fn as_str(self) -> &'static str { + match self { + Self::Stage6 => "stage6", + Self::Stage7 => "stage7", + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum PcsProofMode { + Open, + Verify, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct OpeningInputPlan { pub symbol: &'static str, @@ -56,7 +166,7 @@ pub struct OpeningInputPlan { pub oracle: &'static str, pub domain: &'static str, pub point_arity: usize, - pub claim_kind: &'static str, + pub claim_kind: ClaimKind, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -66,11 +176,21 @@ pub struct FieldConstantPlan { pub value: usize, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum FieldExprKind { + OpeningEval, + Add, + Sub, + Mul, + Neg, + Pow(usize), + LagrangeBasisEval(i64, usize, usize), +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct FieldExprPlan { pub symbol: &'static str, - pub kind: &'static str, - pub formula: &'static str, + pub kind: FieldExprKind, pub operands: &'static str, } @@ -83,7 +203,7 @@ pub struct SumcheckClaimPlan { pub degree: usize, pub claim: &'static str, pub kernel: Option<&'static str>, - pub relation: Option<&'static str>, + pub relation: Option, pub claim_value: &'static str, pub input_openings: &'static str, } @@ -108,7 +228,7 @@ pub struct SumcheckDriverPlan { pub stage: &'static str, pub proof_slot: &'static str, pub kernel: Option<&'static str>, - pub relation: Option<&'static str>, + pub relation: Option, pub batch: &'static str, pub policy: &'static str, pub round_schedule: &'static [usize], @@ -123,7 +243,7 @@ pub struct SumcheckInstanceResultPlan { pub symbol: &'static str, pub source: &'static str, pub claim: &'static str, - pub relation: &'static str, + pub relation: RelationKind, pub index: usize, pub point_arity: usize, pub num_rounds: usize, @@ -171,15 +291,20 @@ pub struct OpeningClaimPlan { pub oracle: &'static str, pub domain: &'static str, pub point_arity: usize, - pub claim_kind: &'static str, + pub claim_kind: ClaimKind, pub point_source: &'static str, pub eval_source: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum OpeningEqualityMode { + PointAndEval, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct OpeningClaimEqualityPlan { pub symbol: &'static str, - pub mode: &'static str, + pub mode: OpeningEqualityMode, pub lhs: &'static str, pub rhs: &'static str, } @@ -366,10 +491,6 @@ pub enum RuntimePlanError { driver: &'static str, reason: &'static str, }, - UnsupportedFieldExpr { - symbol: &'static str, - formula: &'static str, - }, } macro_rules! impl_runtime_plan_error_conversion { @@ -398,9 +519,6 @@ macro_rules! impl_runtime_plan_error_conversion { super::common::RuntimePlanError::InvalidProof { driver, reason } => { Self::InvalidProof { driver, reason } } - super::common::RuntimePlanError::UnsupportedFieldExpr { symbol, formula } => { - Self::UnsupportedFieldExpr { symbol, formula } - } } } } @@ -556,7 +674,7 @@ impl ValueStore { invalid_input_length: impl Fn(&'static str, usize, usize) -> E, ) -> Result<(), E> { self.insert_point(plan.symbol, values.to_vec()); - if matches!(plan.kind, "challenge_scalar" | "scalar") { + if plan.kind.is_scalar() { if values.len() != 1 { return Err(invalid_input_length(plan.symbol, 1, values.len())); } @@ -678,7 +796,7 @@ impl ValueStore { ) -> Result<(), E> { for equality in opening_equalities { match equality.mode { - "point_and_eval" => { + OpeningEqualityMode::PointAndEval => { if self.point_or(equality.lhs, &missing_value)? != self.point_or(equality.rhs, &missing_value)? || self.scalar_or(equality.lhs, &missing_value)? @@ -690,12 +808,6 @@ impl ValueStore { )); } } - _ => { - return Err(invalid_proof( - equality.symbol, - "unsupported opening equality mode", - )); - } } } Ok(()) @@ -1012,39 +1124,39 @@ pub fn evaluate_field_expr( expr: &FieldExprPlan, operands: &[F], ) -> Result { - match expr.formula { - "opening_eval" => Ok(single_operand(expr.symbol, operands)?), - "field.add" => { + match expr.kind { + FieldExprKind::OpeningEval => Ok(single_operand(expr.symbol, operands)?), + FieldExprKind::Add => { require_operand_count(expr.symbol, 2, operands.len())?; Ok(operands[0] + operands[1]) } - "field.sub" => { + FieldExprKind::Sub => { require_operand_count(expr.symbol, 2, operands.len())?; Ok(operands[0] - operands[1]) } - "field.mul" => { + FieldExprKind::Mul => { require_operand_count(expr.symbol, 2, operands.len())?; Ok(operands[0] * operands[1]) } - "field.neg" => { + FieldExprKind::Neg => { require_operand_count(expr.symbol, 1, operands.len())?; Ok(-operands[0]) } - formula => { - if let Some(exponent) = formula.strip_prefix("field.pow:") { - require_operand_count(expr.symbol, 1, operands.len())?; - let exponent = exponent.parse::().map_err(|_| { - RuntimePlanError::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - } - })?; - return Ok(pow_field(operands[0], exponent)); - } - Err(RuntimePlanError::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - }) + FieldExprKind::Pow(exponent) => { + require_operand_count(expr.symbol, 1, operands.len())?; + Ok(pow_field(operands[0], exponent)) + } + FieldExprKind::LagrangeBasisEval(domain_start, domain_size, index) => { + require_operand_count(expr.symbol, 1, operands.len())?; + let weights = lagrange_evals(domain_start, domain_size, operands[0]); + weights + .get(index) + .copied() + .ok_or(RuntimePlanError::InvalidInputLength { + input: expr.symbol, + expected: index + 1, + actual: weights.len(), + }) } } } @@ -1149,7 +1261,6 @@ pub fn normalize_instruction_read_raf_point( #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage67RelationSymbols { - pub hamming_booleanity_relation: &'static str, pub hamming_booleanity_instance: &'static str, pub booleanity_point: &'static str, pub stage5_instruction_ra0: &'static str, @@ -1226,7 +1337,7 @@ pub fn stage67_trace_rounds( ) -> Result { instance_results .iter() - .find(|instance| instance.relation == symbols.hamming_booleanity_relation) + .find(|instance| instance.relation == RelationKind::Stage6HammingBooleanity) .map(|instance| instance.num_rounds) .ok_or(RuntimePlanError::MissingValue { symbol: symbols.hamming_booleanity_instance, diff --git a/crates/jolt-verifier/src/stages/stage1_outer.rs b/crates/jolt-verifier/src/stages/stage1_outer.rs index 8d08183783..01f22a230f 100644 --- a/crates/jolt-verifier/src/stages/stage1_outer.rs +++ b/crates/jolt-verifier/src/stages/stage1_outer.rs @@ -16,9 +16,11 @@ pub type Stage1Proof = super::common::StageProof; pub type Stage1VerifierProgramPlan = super::common::VerifierProgramPlanMinimal; pub use super::common::{ - OpeningBatchPlan as Stage1OpeningBatchPlan, OpeningClaimPlan as Stage1OpeningClaimPlan, + ClaimKind as Stage1ClaimKind, RelationKind as Stage1RelationKind, OpeningBatchPlan as Stage1OpeningBatchPlan, + OpeningClaimPlan as Stage1OpeningClaimPlan, SumcheckBatchPlan as Stage1SumcheckBatchPlan, SumcheckEvalPlan as Stage1SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage1SumcheckInstanceResultPlan, + TranscriptSqueezeKind as Stage1TranscriptSqueezeKind, TranscriptSqueezePlan as Stage1TranscriptSqueezePlan, SumcheckClaimPlan as Stage1SumcheckClaimPlan, SumcheckDriverPlan as Stage1SumcheckDriverPlan, @@ -32,50 +34,38 @@ pub enum VerifyStage1Error { MissingClaim { driver: &'static str, claim: &'static str }, MissingDependency { driver: &'static str, dependency: &'static str }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage1RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } -pub const STAGE1_PARAMS: Stage1Params = Stage1Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE1_PARAMS: Stage1Params = Stage1Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE1_TRANSCRIPT_SQUEEZES: &[Stage1TranscriptSqueezePlan] = &[ - Stage1TranscriptSqueezePlan { symbol: "stage1.tau", label: "outer_tau", kind: "challenge_vector", count: 18 }, + Stage1TranscriptSqueezePlan { symbol: "stage1.tau", label: "outer_tau", kind: Stage1TranscriptSqueezeKind::ChallengeVector, count: 18 }, ]; pub const STAGE1_SUMCHECK_CLAIMS: &[Stage1SumcheckClaimPlan] = &[ - Stage1SumcheckClaimPlan { symbol: "stage1.uniskip.input", stage: "stage1", domain: "jolt.stage1_uniskip_domain", num_rounds: 1, degree: 27, claim: "stage1.zero", kernel: None, relation: Some("jolt.stage1.outer.uniskip"), claim_value: "stage1.zero", input_openings: "" }, - Stage1SumcheckClaimPlan { symbol: "stage1.outer_remaining.input", stage: "stage1", domain: "jolt.trace_domain", num_rounds: 17, degree: 3, claim: "stage1.uniskip.eval", kernel: None, relation: Some("jolt.stage1.outer.remaining"), claim_value: "stage1.uniskip.eval", input_openings: "stage1.uniskip.opening" }, -]; -pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 1, + Stage1SumcheckClaimPlan { symbol: "stage1.uniskip.input", stage: "stage1", domain: "jolt.stage1_uniskip_domain", num_rounds: 1, degree: 27, claim: "stage1.zero", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterUniskip), claim_value: "stage1.zero", input_openings: "" }, + Stage1SumcheckClaimPlan { symbol: "stage1.outer_remaining.input", stage: "stage1", domain: "jolt.trace_domain", num_rounds: 17, degree: 3, claim: "stage1.uniskip.eval", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterRemaining), claim_value: "stage1.uniskip.eval", input_openings: "stage1.uniskip.opening" }, ]; +pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1]; -pub const STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[ - 17, -]; +pub const STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[17]; pub const STAGE1_SUMCHECK_BATCHES: &[Stage1SumcheckBatchPlan] = &[ Stage1SumcheckBatchPlan { symbol: "stage1.uniskip.batch", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: "stage1.uniskip.input", claim_operands: "stage1.uniskip.input", claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, Stage1SumcheckBatchPlan { symbol: "stage1.outer_remaining.batch", stage: "stage1", proof_slot: "stage1.sumcheck", policy: "jolt_core_front_loaded", count: 1, ordered_claims: "stage1.outer_remaining.input", claim_operands: "stage1.outer_remaining.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, ]; -pub const STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 1, -]; +pub const STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1]; -pub const STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[ - 17, -]; +pub const STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[17]; pub const STAGE1_SUMCHECK_DRIVERS: &[Stage1SumcheckDriverPlan] = &[ - Stage1SumcheckDriverPlan { symbol: "stage1.uniskip.sumcheck", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", kernel: None, relation: Some("jolt.stage1.outer.uniskip"), batch: "stage1.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 27 }, - Stage1SumcheckDriverPlan { symbol: "stage1.outer_remaining.sumcheck", stage: "stage1", proof_slot: "stage1.sumcheck", kernel: None, relation: Some("jolt.stage1.outer.remaining"), batch: "stage1.outer_remaining.batch", policy: "jolt_core_front_loaded", round_schedule: STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 17, degree: 3 }, + Stage1SumcheckDriverPlan { symbol: "stage1.uniskip.sumcheck", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterUniskip), batch: "stage1.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 27 }, + Stage1SumcheckDriverPlan { symbol: "stage1.outer_remaining.sumcheck", stage: "stage1", proof_slot: "stage1.sumcheck", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterRemaining), batch: "stage1.outer_remaining.batch", policy: "jolt_core_front_loaded", round_schedule: STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 17, degree: 3 }, ]; pub const STAGE1_SUMCHECK_INSTANCE_RESULTS: &[Stage1SumcheckInstanceResultPlan] = &[ - Stage1SumcheckInstanceResultPlan { symbol: "stage1.uniskip.instance", source: "stage1.uniskip.sumcheck", claim: "stage1.uniskip.input", relation: "jolt.stage1.outer.uniskip", index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: "as_is", degree: 27 }, - Stage1SumcheckInstanceResultPlan { symbol: "stage1.outer_remaining.instance", source: "stage1.outer_remaining.sumcheck", claim: "stage1.outer_remaining.input", relation: "jolt.stage1.outer.remaining", index: 0, point_arity: 16, num_rounds: 17, round_offset: 1, point_order: "reverse", degree: 3 }, + Stage1SumcheckInstanceResultPlan { symbol: "stage1.uniskip.instance", source: "stage1.uniskip.sumcheck", claim: "stage1.uniskip.input", relation: Stage1RelationKind::Stage1OuterUniskip, index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: "as_is", degree: 27 }, + Stage1SumcheckInstanceResultPlan { symbol: "stage1.outer_remaining.instance", source: "stage1.outer_remaining.sumcheck", claim: "stage1.outer_remaining.input", relation: Stage1RelationKind::Stage1OuterRemaining, index: 0, point_arity: 16, num_rounds: 17, round_offset: 1, point_order: "reverse", degree: 3 }, ]; pub const STAGE1_SUMCHECK_EVALS: &[Stage1SumcheckEvalPlan] = &[ @@ -118,42 +108,42 @@ pub const STAGE1_SUMCHECK_EVALS: &[Stage1SumcheckEvalPlan] = &[ ]; pub const STAGE1_OPENING_CLAIMS: &[Stage1OpeningClaimPlan] = &[ - Stage1OpeningClaimPlan { symbol: "stage1.uniskip.opening", oracle: "UnivariateSkip", domain: "jolt.stage1_uniskip_domain", point_arity: 1, claim_kind: "virtual", point_source: "stage1.uniskip.instance", eval_source: "stage1.uniskip.eval" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LeftInstructionInput" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RightInstructionInput" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Product", oracle: "Product", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Product" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.ShouldBranch", oracle: "ShouldBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.ShouldBranch" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.PC" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.UnexpandedPC" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Imm" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamAddress", oracle: "RamAddress", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamAddress" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Rs1Value" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Rs2Value" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RdWriteValue" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamReadValue", oracle: "RamReadValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamReadValue" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamWriteValue", oracle: "RamWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamWriteValue" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LeftLookupOperand" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RightLookupOperand" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextUnexpandedPC", oracle: "NextUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextUnexpandedPC" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextPC", oracle: "NextPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextPC" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextIsVirtual", oracle: "NextIsVirtual", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextIsVirtual" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextIsFirstInSequence", oracle: "NextIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextIsFirstInSequence" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LookupOutput" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.ShouldJump", oracle: "ShouldJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.ShouldJump" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAddOperands", oracle: "OpFlagAddOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAddOperands" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagSubtractOperands", oracle: "OpFlagSubtractOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagSubtractOperands" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagMultiplyOperands", oracle: "OpFlagMultiplyOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagMultiplyOperands" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagLoad", oracle: "OpFlagLoad", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagLoad" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagStore", oracle: "OpFlagStore", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagStore" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagJump" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagWriteLookupOutputToRD" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagVirtualInstruction" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAssert", oracle: "OpFlagAssert", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAssert" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", oracle: "OpFlagDoNotUpdateUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagDoNotUpdateUnexpandedPC" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAdvice", oracle: "OpFlagAdvice", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAdvice" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsCompressed", oracle: "OpFlagIsCompressed", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsCompressed" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsFirstInSequence" }, - Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsLastInSequence", oracle: "OpFlagIsLastInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsLastInSequence" }, + Stage1OpeningClaimPlan { symbol: "stage1.uniskip.opening", oracle: "UnivariateSkip", domain: "jolt.stage1_uniskip_domain", point_arity: 1, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.uniskip.instance", eval_source: "stage1.uniskip.eval" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LeftInstructionInput" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RightInstructionInput" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Product", oracle: "Product", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Product" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.ShouldBranch", oracle: "ShouldBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.ShouldBranch" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.PC" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.UnexpandedPC" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Imm" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamAddress", oracle: "RamAddress", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamAddress" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Rs1Value" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.Rs2Value" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RdWriteValue" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamReadValue", oracle: "RamReadValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamReadValue" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RamWriteValue", oracle: "RamWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RamWriteValue" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LeftLookupOperand" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.RightLookupOperand" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextUnexpandedPC", oracle: "NextUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextUnexpandedPC" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextPC", oracle: "NextPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextPC" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextIsVirtual", oracle: "NextIsVirtual", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextIsVirtual" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.NextIsFirstInSequence", oracle: "NextIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.NextIsFirstInSequence" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.LookupOutput" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.ShouldJump", oracle: "ShouldJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.ShouldJump" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAddOperands", oracle: "OpFlagAddOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAddOperands" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagSubtractOperands", oracle: "OpFlagSubtractOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagSubtractOperands" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagMultiplyOperands", oracle: "OpFlagMultiplyOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagMultiplyOperands" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagLoad", oracle: "OpFlagLoad", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagLoad" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagStore", oracle: "OpFlagStore", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagStore" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagJump" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagWriteLookupOutputToRD" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagVirtualInstruction" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAssert", oracle: "OpFlagAssert", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAssert" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", oracle: "OpFlagDoNotUpdateUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagDoNotUpdateUnexpandedPC" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagAdvice", oracle: "OpFlagAdvice", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagAdvice" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsCompressed", oracle: "OpFlagIsCompressed", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsCompressed" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsFirstInSequence" }, + Stage1OpeningClaimPlan { symbol: "stage1.outer_remaining.opening.OpFlagIsLastInSequence", oracle: "OpFlagIsLastInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage1ClaimKind::Virtual, point_source: "stage1.outer_remaining.instance", eval_source: "stage1.outer_remaining.eval.OpFlagIsLastInSequence" }, ]; pub const STAGE1_OPENING_BATCHES: &[Stage1OpeningBatchPlan] = &[ @@ -236,10 +226,17 @@ where reason: "driver symbol mismatch", }); } - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage1Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; match relation { - "jolt.stage1.outer.uniskip" => verify_outer_uniskip(program, driver, proof, transcript), - "jolt.stage1.outer.remaining" => { + Stage1RelationKind::Stage1OuterUniskip => { + verify_outer_uniskip(program, driver, proof, transcript) + } + Stage1RelationKind::Stage1OuterRemaining => { verify_outer_remaining(program, driver, proof, completed, transcript) } relation => Err(VerifyStage1Error::UnsupportedRelation { relation }), diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index 065ee77697..6818946666 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use super::common::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, pow_field, require_operand_count, reverse_slice, single_operand}; +use super::common::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt, RingCore}; use jolt_poly::lagrange::{lagrange_evals, lagrange_kernel_eval}; use jolt_poly::{EqPolynomial, UnivariatePoly}; @@ -18,13 +18,17 @@ pub type Stage2OpeningInputValue = super::common::StageOpeningInputValue; pub type Stage2VerifierProgramPlan = super::common::StageVerifierProgramPlanNoEqualities; pub use super::common::{ - FieldConstantPlan as Stage2FieldConstantPlan, FieldExprPlan as Stage2FieldExprPlan, + ClaimKind as Stage2ClaimKind, RelationKind as Stage2RelationKind, FieldConstantPlan as Stage2FieldConstantPlan, + FieldExprKind as Stage2FieldExprKind, + FieldExprPlan as Stage2FieldExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, OpeningInputPlan as Stage2OpeningInputPlan, PointConcatPlan as Stage2PointConcatPlan, - PointSlicePlan as Stage2PointSlicePlan, ProgramStepPlan as Stage2ProgramStepPlan, - StageParams as Stage2Params, SumcheckBatchPlan as Stage2SumcheckBatchPlan, + PointSlicePlan as Stage2PointSlicePlan, ProgramStepKind as Stage2ProgramStepKind, + ProgramStepPlan as Stage2ProgramStepPlan, StageParams as Stage2Params, + SumcheckBatchPlan as Stage2SumcheckBatchPlan, SumcheckEvalPlan as Stage2SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage2SumcheckInstanceResultPlan, + TranscriptSqueezeKind as Stage2TranscriptSqueezeKind, TranscriptSqueezePlan as Stage2TranscriptSqueezePlan, SumcheckClaimPlan as Stage2SumcheckClaimPlan, SumcheckDriverPlan as Stage2SumcheckDriverPlan, @@ -65,47 +69,42 @@ pub enum VerifyStage2Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage2RelationKind }, MissingRam { relation: &'static str }, Sumcheck { driver: &'static str, error: SumcheckError }, } super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); -pub const STAGE2_PARAMS: Stage2Params = Stage2Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE2_PARAMS: Stage2Params = Stage2Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE2_PROGRAM_STEPS: &[Stage2ProgramStepPlan] = &[ - Stage2ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage2.product_virtual.tau_high" }, - Stage2ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage2.product_virtual.uniskip.sumcheck" }, - Stage2ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage2.ram_read_write.gamma" }, - Stage2ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage2.instruction_lookup.gamma" }, - Stage2ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage2.ram_output.r_address" }, - Stage2ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage2.sumcheck" }, + Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::TranscriptSqueeze, symbol: "stage2.product_virtual.tau_high" }, + Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::SumcheckDriver, symbol: "stage2.product_virtual.uniskip.sumcheck" }, + Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::TranscriptSqueeze, symbol: "stage2.ram_read_write.gamma" }, + Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::TranscriptSqueeze, symbol: "stage2.instruction_lookup.gamma" }, + Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::TranscriptSqueeze, symbol: "stage2.ram_output.r_address" }, + Stage2ProgramStepPlan { kind: Stage2ProgramStepKind::SumcheckDriver, symbol: "stage2.sumcheck" }, ]; pub const STAGE2_TRANSCRIPT_SQUEEZES: &[Stage2TranscriptSqueezePlan] = &[ - Stage2TranscriptSqueezePlan { symbol: "stage2.product_virtual.tau_high", label: "product_virtual_tau_high", kind: "challenge_scalar", count: 1 }, - Stage2TranscriptSqueezePlan { symbol: "stage2.ram_read_write.gamma", label: "ram_read_write_gamma", kind: "challenge_scalar", count: 1 }, - Stage2TranscriptSqueezePlan { symbol: "stage2.instruction_lookup.gamma", label: "instruction_lookup_gamma", kind: "challenge_scalar", count: 1 }, - Stage2TranscriptSqueezePlan { symbol: "stage2.ram_output.r_address", label: "ram_output_r_address", kind: "challenge_vector", count: 16 }, + Stage2TranscriptSqueezePlan { symbol: "stage2.product_virtual.tau_high", label: "product_virtual_tau_high", kind: Stage2TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage2TranscriptSqueezePlan { symbol: "stage2.ram_read_write.gamma", label: "ram_read_write_gamma", kind: Stage2TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage2TranscriptSqueezePlan { symbol: "stage2.instruction_lookup.gamma", label: "instruction_lookup_gamma", kind: Stage2TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage2TranscriptSqueezePlan { symbol: "stage2.ram_output.r_address", label: "ram_output_r_address", kind: Stage2TranscriptSqueezeKind::ChallengeVector, count: 16 }, ]; pub const STAGE2_OPENING_INPUTS: &[Stage2OpeningInputPlan] = &[ - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.Product", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Product", oracle: "Product", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.ShouldBranch", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.ShouldBranch", oracle: "ShouldBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.ShouldJump", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.ShouldJump", oracle: "ShouldJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamReadValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamReadValue", oracle: "RamReadValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamWriteValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamWriteValue", oracle: "RamWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LookupOutput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LeftLookupOperand", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RightLookupOperand", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LeftInstructionInput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RightInstructionInput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamAddress", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamAddress", oracle: "RamAddress", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.Product", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Product", oracle: "Product", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.ShouldBranch", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.ShouldBranch", oracle: "ShouldBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.ShouldJump", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.ShouldJump", oracle: "ShouldJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamReadValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamReadValue", oracle: "RamReadValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamWriteValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamWriteValue", oracle: "RamWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LookupOutput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LeftLookupOperand", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RightLookupOperand", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.LeftInstructionInput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RightInstructionInput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, + Stage2OpeningInputPlan { symbol: "stage2.input.stage1.RamAddress", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RamAddress", oracle: "RamAddress", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual }, ]; pub const STAGE2_FIELD_CONSTANTS: &[Stage2FieldConstantPlan] = &[ @@ -113,69 +112,59 @@ pub const STAGE2_FIELD_CONSTANTS: &[Stage2FieldConstantPlan] = &[ ]; pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.Product", kind: "op", formula: "poly.lagrange_basis_eval:-1:3:0", operands: "stage2.product_virtual.tau_high" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldBranch", kind: "op", formula: "poly.lagrange_basis_eval:-1:3:1", operands: "stage2.product_virtual.tau_high" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldJump", kind: "op", formula: "poly.lagrange_basis_eval:-1:3:2", operands: "stage2.product_virtual.tau_high" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.Product", kind: "op", formula: "field.mul", operands: "stage2.product_virtual.uniskip.weight.Product|stage2.input.stage1.Product" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldBranch", kind: "op", formula: "field.mul", operands: "stage2.product_virtual.uniskip.weight.ShouldBranch|stage2.input.stage1.ShouldBranch" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldJump", kind: "op", formula: "field.mul", operands: "stage2.product_virtual.uniskip.weight.ShouldJump|stage2.input.stage1.ShouldJump" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.partial.ProductShouldBranch", kind: "op", formula: "field.add", operands: "stage2.product_virtual.uniskip.term.Product|stage2.product_virtual.uniskip.term.ShouldBranch" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.claim_expr", kind: "op", formula: "field.add", operands: "stage2.product_virtual.uniskip.partial.ProductShouldBranch|stage2.product_virtual.uniskip.term.ShouldJump" }, - Stage2FieldExprPlan { symbol: "stage2.ram_read_write.term.RamWriteValue", kind: "op", formula: "field.mul", operands: "stage2.ram_read_write.gamma|stage2.input.stage1.RamWriteValue" }, - Stage2FieldExprPlan { symbol: "stage2.ram_read_write.claim_expr", kind: "op", formula: "field.add", operands: "stage2.input.stage1.RamReadValue|stage2.ram_read_write.term.RamWriteValue" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma2", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma|stage2.instruction_lookup.gamma" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma3", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma2|stage2.instruction_lookup.gamma" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma4", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma2|stage2.instruction_lookup.gamma2" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftLookupOperand", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma|stage2.input.stage1.LeftLookupOperand" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightLookupOperand", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma2|stage2.input.stage1.RightLookupOperand" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftInstructionInput", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma3|stage2.input.stage1.LeftInstructionInput" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightInstructionInput", kind: "op", formula: "field.mul", operands: "stage2.instruction_lookup.gamma4|stage2.input.stage1.RightInstructionInput" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LookupOutputLeftOperand", kind: "op", formula: "field.add", operands: "stage2.input.stage1.LookupOutput|stage2.instruction_lookup.term.LeftLookupOperand" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.RightOperand", kind: "op", formula: "field.add", operands: "stage2.instruction_lookup.partial.LookupOutputLeftOperand|stage2.instruction_lookup.term.RightLookupOperand" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LeftInstructionInput", kind: "op", formula: "field.add", operands: "stage2.instruction_lookup.partial.RightOperand|stage2.instruction_lookup.term.LeftInstructionInput" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: "op", formula: "field.add", operands: "stage2.instruction_lookup.partial.LeftInstructionInput|stage2.instruction_lookup.term.RightInstructionInput" }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.Product", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 0), operands: "stage2.product_virtual.tau_high" }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldBranch", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 1), operands: "stage2.product_virtual.tau_high" }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldJump", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 2), operands: "stage2.product_virtual.tau_high" }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.Product", kind: Stage2FieldExprKind::Mul, operands: "stage2.product_virtual.uniskip.weight.Product|stage2.input.stage1.Product" }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldBranch", kind: Stage2FieldExprKind::Mul, operands: "stage2.product_virtual.uniskip.weight.ShouldBranch|stage2.input.stage1.ShouldBranch" }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldJump", kind: Stage2FieldExprKind::Mul, operands: "stage2.product_virtual.uniskip.weight.ShouldJump|stage2.input.stage1.ShouldJump" }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.partial.ProductShouldBranch", kind: Stage2FieldExprKind::Add, operands: "stage2.product_virtual.uniskip.term.Product|stage2.product_virtual.uniskip.term.ShouldBranch" }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.claim_expr", kind: Stage2FieldExprKind::Add, operands: "stage2.product_virtual.uniskip.partial.ProductShouldBranch|stage2.product_virtual.uniskip.term.ShouldJump" }, + Stage2FieldExprPlan { symbol: "stage2.ram_read_write.term.RamWriteValue", kind: Stage2FieldExprKind::Mul, operands: "stage2.ram_read_write.gamma|stage2.input.stage1.RamWriteValue" }, + Stage2FieldExprPlan { symbol: "stage2.ram_read_write.claim_expr", kind: Stage2FieldExprKind::Add, operands: "stage2.input.stage1.RamReadValue|stage2.ram_read_write.term.RamWriteValue" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma2", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma|stage2.instruction_lookup.gamma" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma3", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma2|stage2.instruction_lookup.gamma" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma4", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma2|stage2.instruction_lookup.gamma2" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftLookupOperand", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma|stage2.input.stage1.LeftLookupOperand" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightLookupOperand", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma2|stage2.input.stage1.RightLookupOperand" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftInstructionInput", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma3|stage2.input.stage1.LeftInstructionInput" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightInstructionInput", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma4|stage2.input.stage1.RightInstructionInput" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LookupOutputLeftOperand", kind: Stage2FieldExprKind::Add, operands: "stage2.input.stage1.LookupOutput|stage2.instruction_lookup.term.LeftLookupOperand" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.RightOperand", kind: Stage2FieldExprKind::Add, operands: "stage2.instruction_lookup.partial.LookupOutputLeftOperand|stage2.instruction_lookup.term.RightLookupOperand" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LeftInstructionInput", kind: Stage2FieldExprKind::Add, operands: "stage2.instruction_lookup.partial.RightOperand|stage2.instruction_lookup.term.LeftInstructionInput" }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: Stage2FieldExprKind::Add, operands: "stage2.instruction_lookup.partial.LeftInstructionInput|stage2.instruction_lookup.term.RightInstructionInput" }, ]; pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[ - Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some("jolt.stage2.product_virtual.uniskip"), claim_value: "stage2.product_virtual.uniskip.claim_expr", input_openings: "stage2.input.stage1.Product|stage2.input.stage1.ShouldBranch|stage2.input.stage1.ShouldJump" }, - Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some("jolt.stage2.ram.read_write"), claim_value: "stage2.ram_read_write.claim_expr", input_openings: "stage2.input.stage1.RamReadValue|stage2.input.stage1.RamWriteValue" }, - Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.remainder.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage2.product_virtual.uniskip.opening", kernel: None, relation: Some("jolt.stage2.product_virtual.remainder"), claim_value: "stage2.product_virtual.uniskip.eval.UnivariateSkip", input_openings: "stage2.product_virtual.uniskip.opening.UnivariateSkip" }, - Stage2SumcheckClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage2.instruction_lookup.weighted_operands", kernel: None, relation: Some("jolt.stage2.instruction_lookup.claim_reduction"), claim_value: "stage2.instruction_lookup.claim_reduction.claim_expr", input_openings: "stage2.input.stage1.LookupOutput|stage2.input.stage1.LeftLookupOperand|stage2.input.stage1.RightLookupOperand|stage2.input.stage1.LeftInstructionInput|stage2.input.stage1.RightInstructionInput" }, - Stage2SumcheckClaimPlan { symbol: "stage2.ram_raf.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 2, claim: "stage2.ram_raf.ram_address", kernel: None, relation: Some("jolt.stage2.ram.raf_evaluation"), claim_value: "stage2.input.stage1.RamAddress", input_openings: "stage2.input.stage1.RamAddress" }, - Stage2SumcheckClaimPlan { symbol: "stage2.ram_output.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 3, claim: "zero", kernel: None, relation: Some("jolt.stage2.ram.output_check"), claim_value: "stage2.ram_output.zero", input_openings: "" }, -]; -pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 1, + Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr", input_openings: "stage2.input.stage1.Product|stage2.input.stage1.ShouldBranch|stage2.input.stage1.ShouldJump" }, + Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some(Stage2RelationKind::Stage2RamReadWrite), claim_value: "stage2.ram_read_write.claim_expr", input_openings: "stage2.input.stage1.RamReadValue|stage2.input.stage1.RamWriteValue" }, + Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.remainder.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage2.product_virtual.uniskip.opening", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualRemainder), claim_value: "stage2.product_virtual.uniskip.eval.UnivariateSkip", input_openings: "stage2.product_virtual.uniskip.opening.UnivariateSkip" }, + Stage2SumcheckClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage2.instruction_lookup.weighted_operands", kernel: None, relation: Some(Stage2RelationKind::Stage2InstructionLookupClaimReduction), claim_value: "stage2.instruction_lookup.claim_reduction.claim_expr", input_openings: "stage2.input.stage1.LookupOutput|stage2.input.stage1.LeftLookupOperand|stage2.input.stage1.RightLookupOperand|stage2.input.stage1.LeftInstructionInput|stage2.input.stage1.RightInstructionInput" }, + Stage2SumcheckClaimPlan { symbol: "stage2.ram_raf.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 2, claim: "stage2.ram_raf.ram_address", kernel: None, relation: Some(Stage2RelationKind::Stage2RamRafEvaluation), claim_value: "stage2.input.stage1.RamAddress", input_openings: "stage2.input.stage1.RamAddress" }, + Stage2SumcheckClaimPlan { symbol: "stage2.ram_output.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 3, claim: "zero", kernel: None, relation: Some(Stage2RelationKind::Stage2RamOutputCheck), claim_value: "stage2.ram_output.zero", input_openings: "" }, ]; +pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1]; -pub const STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[ - 16, - 16, -]; +pub const STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[16, 16]; pub const STAGE2_SUMCHECK_BATCHES: &[Stage2SumcheckBatchPlan] = &[ Stage2SumcheckBatchPlan { symbol: "stage2.product_virtual.uniskip.batch", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: "stage2.product_virtual.uniskip.input", claim_operands: "stage2.product_virtual.uniskip.input", claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, Stage2SumcheckBatchPlan { symbol: "stage2.batch", stage: "stage2", proof_slot: "stage2.sumcheck", policy: "jolt_core_stage2_aligned", count: 5, ordered_claims: "stage2.ram_read_write.input|stage2.product_virtual.remainder.input|stage2.instruction_lookup.claim_reduction.input|stage2.ram_raf.input|stage2.ram_output.input", claim_operands: "stage2.ram_read_write.input|stage2.product_virtual.remainder.input|stage2.instruction_lookup.claim_reduction.input|stage2.ram_raf.input|stage2.ram_output.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, ]; -pub const STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 1, -]; +pub const STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1]; -pub const STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[ - 16, - 16, -]; +pub const STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE: &[usize] = &[16, 16]; pub const STAGE2_SUMCHECK_DRIVERS: &[Stage2SumcheckDriverPlan] = &[ - Stage2SumcheckDriverPlan { symbol: "stage2.product_virtual.uniskip.sumcheck", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", kernel: None, relation: Some("jolt.stage2.product_virtual.uniskip"), batch: "stage2.product_virtual.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 6 }, - Stage2SumcheckDriverPlan { symbol: "stage2.sumcheck", stage: "stage2", proof_slot: "stage2.sumcheck", kernel: None, relation: Some("jolt.stage2.batched"), batch: "stage2.batch", policy: "jolt_core_stage2_aligned", round_schedule: STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 32, degree: 3 }, + Stage2SumcheckDriverPlan { symbol: "stage2.product_virtual.uniskip.sumcheck", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), batch: "stage2.product_virtual.uniskip.batch", policy: "univariate_skip", round_schedule: STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "uniskip_claim", round_label: "uniskip_poly", num_rounds: 1, degree: 6 }, + Stage2SumcheckDriverPlan { symbol: "stage2.sumcheck", stage: "stage2", proof_slot: "stage2.sumcheck", kernel: None, relation: Some(Stage2RelationKind::Stage2Batched), batch: "stage2.batch", policy: "jolt_core_stage2_aligned", round_schedule: STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 32, degree: 3 }, ]; pub const STAGE2_SUMCHECK_INSTANCE_RESULTS: &[Stage2SumcheckInstanceResultPlan] = &[ - Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.uniskip.instance", source: "stage2.product_virtual.uniskip.sumcheck", claim: "stage2.product_virtual.uniskip.input", relation: "jolt.stage2.product_virtual.uniskip", index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: "as_is", degree: 6 }, - Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_read_write.instance", source: "stage2.sumcheck", claim: "stage2.ram_read_write.input", relation: "jolt.stage2.ram.read_write", index: 0, point_arity: 32, num_rounds: 32, round_offset: 0, point_order: "reverse", degree: 3 }, - Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.remainder.instance", source: "stage2.sumcheck", claim: "stage2.product_virtual.remainder.input", relation: "jolt.stage2.product_virtual.remainder", index: 1, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 3 }, - Stage2SumcheckInstanceResultPlan { symbol: "stage2.instruction_lookup.claim_reduction.instance", source: "stage2.sumcheck", claim: "stage2.instruction_lookup.claim_reduction.input", relation: "jolt.stage2.instruction_lookup.claim_reduction", index: 2, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 2 }, - Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_raf.instance", source: "stage2.sumcheck", claim: "stage2.ram_raf.input", relation: "jolt.stage2.ram.raf_evaluation", index: 3, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 2 }, - Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_output.instance", source: "stage2.sumcheck", claim: "stage2.ram_output.input", relation: "jolt.stage2.ram.output_check", index: 4, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 3 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.uniskip.instance", source: "stage2.product_virtual.uniskip.sumcheck", claim: "stage2.product_virtual.uniskip.input", relation: Stage2RelationKind::Stage2ProductVirtualUniskip, index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: "as_is", degree: 6 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_read_write.instance", source: "stage2.sumcheck", claim: "stage2.ram_read_write.input", relation: Stage2RelationKind::Stage2RamReadWrite, index: 0, point_arity: 32, num_rounds: 32, round_offset: 0, point_order: "reverse", degree: 3 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.remainder.instance", source: "stage2.sumcheck", claim: "stage2.product_virtual.remainder.input", relation: Stage2RelationKind::Stage2ProductVirtualRemainder, index: 1, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 3 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.instruction_lookup.claim_reduction.instance", source: "stage2.sumcheck", claim: "stage2.instruction_lookup.claim_reduction.input", relation: Stage2RelationKind::Stage2InstructionLookupClaimReduction, index: 2, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 2 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_raf.instance", source: "stage2.sumcheck", claim: "stage2.ram_raf.input", relation: Stage2RelationKind::Stage2RamRafEvaluation, index: 3, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 2 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_output.instance", source: "stage2.sumcheck", claim: "stage2.ram_output.input", relation: Stage2RelationKind::Stage2RamOutputCheck, index: 4, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 3 }, ]; pub const STAGE2_SUMCHECK_EVALS: &[Stage2SumcheckEvalPlan] = &[ @@ -208,25 +197,25 @@ pub const STAGE2_POINT_CONCATS: &[Stage2PointConcatPlan] = &[ Stage2PointConcatPlan { symbol: "stage2.ram_raf.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: "stage2.ram_raf.instance|stage2.input.stage1.RamAddress" }, ]; pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[ - Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.uniskip.opening.UnivariateSkip", oracle: "UnivariateSkip", domain: "jolt.stage2_uniskip_domain", point_arity: 1, claim_kind: "virtual", point_source: "stage2.product_virtual.uniskip.instance", eval_source: "stage2.product_virtual.uniskip.eval.UnivariateSkip" }, - Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamVal", oracle: "RamVal", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage2.ram_read_write.instance", eval_source: "stage2.ram_read_write.eval.RamVal" }, - Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage2.ram_read_write.instance", eval_source: "stage2.ram_read_write.eval.RamRa" }, - Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage2.ram_read_write.point.RamInc", eval_source: "stage2.ram_read_write.eval.RamInc" }, - Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.LeftInstructionInput" }, - Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.RightInstructionInput" }, - Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagJump" }, - Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagWriteLookupOutputToRD" }, - Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.LookupOutput" }, - Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.InstructionFlagBranch", oracle: "InstructionFlagBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.InstructionFlagBranch" }, - Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.NextIsNoop", oracle: "NextIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.NextIsNoop" }, - Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagVirtualInstruction" }, - Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LookupOutput" }, - Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand" }, - Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand" }, - Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput" }, - Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput" }, - Stage2OpeningClaimPlan { symbol: "stage2.ram_raf.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage2.ram_raf.point.RamRa", eval_source: "stage2.ram_raf.eval.RamRa" }, - Stage2OpeningClaimPlan { symbol: "stage2.ram_output.opening.RamValFinal", oracle: "RamValFinal", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage2.ram_output.instance", eval_source: "stage2.ram_output.eval.RamValFinal" }, + Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.uniskip.opening.UnivariateSkip", oracle: "UnivariateSkip", domain: "jolt.stage2_uniskip_domain", point_arity: 1, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.uniskip.instance", eval_source: "stage2.product_virtual.uniskip.eval.UnivariateSkip" }, + Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamVal", oracle: "RamVal", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.ram_read_write.instance", eval_source: "stage2.ram_read_write.eval.RamVal" }, + Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.ram_read_write.instance", eval_source: "stage2.ram_read_write.eval.RamRa" }, + Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Committed, point_source: "stage2.ram_read_write.point.RamInc", eval_source: "stage2.ram_read_write.eval.RamInc" }, + Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.LeftInstructionInput" }, + Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.RightInstructionInput" }, + Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagJump" }, + Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagWriteLookupOutputToRD" }, + Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.LookupOutput" }, + Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.InstructionFlagBranch", oracle: "InstructionFlagBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.InstructionFlagBranch" }, + Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.NextIsNoop", oracle: "NextIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.NextIsNoop" }, + Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.remainder.instance", eval_source: "stage2.product_virtual.remainder.eval.OpFlagVirtualInstruction" }, + Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LookupOutput" }, + Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand" }, + Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand" }, + Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput" }, + Stage2OpeningClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.instruction_lookup.claim_reduction.instance", eval_source: "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput" }, + Stage2OpeningClaimPlan { symbol: "stage2.ram_raf.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.ram_raf.point.RamRa", eval_source: "stage2.ram_raf.eval.RamRa" }, + Stage2OpeningClaimPlan { symbol: "stage2.ram_output.opening.RamValFinal", oracle: "RamValFinal", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.ram_output.instance", eval_source: "stage2.ram_output.eval.RamValFinal" }, ]; pub const STAGE2_OPENING_BATCHES: &[Stage2OpeningBatchPlan] = &[ @@ -294,19 +283,19 @@ where } else { for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage2ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage2Error::MissingValue { symbol: step.symbol, })?; verify_stage2_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "sumcheck_driver" => { + Stage2ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage2Error::MissingProof { driver: step.symbol, })?; verify_stage2_driver(program, driver, proof, ram, &mut store, transcript, &mut artifacts)?; } - _ => { + Stage2ProgramStepKind::TranscriptAbsorbBytes => { return Err(VerifyStage2Error::InvalidProof { driver: step.symbol, reason: "unsupported stage2 program step", @@ -369,12 +358,19 @@ where .ok_or(VerifyStage2Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage2Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage2.product_virtual.uniskip" => { + Stage2RelationKind::Stage2ProductVirtualUniskip => { verify_product_virtual_uniskip(program, driver, proof, store, transcript)? } - "jolt.stage2.batched" => verify_batched_stage2(program, driver, proof, ram, store, transcript)?, + Stage2RelationKind::Stage2Batched => { + verify_batched_stage2(program, driver, proof, ram, store, transcript)? + } relation => return Err(VerifyStage2Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); @@ -553,15 +549,15 @@ impl Stage2ValueStore { output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), - _ => { - return Err(VerifyStage2Error::InvalidProof { - driver: output.driver, - reason: "unsupported point order", - }); - } + "as_is" => {} + "reverse" => point.reverse(), + _ => { + return Err(VerifyStage2Error::InvalidProof { + driver: output.driver, + reason: "unsupported point order", + }); } + } Ok(point) }, |input, expected, actual| VerifyStage2Error::InvalidInputLength { @@ -621,7 +617,8 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, ) -> Result<(), VerifyStage2Error> { self.0 - .evaluate_available_field_exprs(program.field_exprs, evaluate_stage2_field_expr) + .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .map_err(VerifyStage2Error::from) } fn scalar(&self, symbol: &'static str) -> Result { @@ -639,109 +636,6 @@ impl Stage2ValueStore { } } -fn evaluate_stage2_field_expr( - expr: &Stage2FieldExprPlan, - operands: &[F], -) -> Result { - match expr.formula { - "opening_eval" => Ok(single_operand(expr.symbol, operands)?), - "jolt_stage2_product_virtual_uniskip_input" => { - require_operand_count(expr.symbol, 4, operands.len())?; - let weights = lagrange_evals( - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START, - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE, - operands[0], - ); - Ok(weights[0] * operands[1] + weights[1] * operands[2] + weights[2] * operands[3]) - } - "jolt_stage2_ram_read_write_input" => { - require_operand_count(expr.symbol, 3, operands.len())?; - Ok(operands[1] + operands[0] * operands[2]) - } - "jolt_stage2_instruction_lookup_input" => { - require_operand_count(expr.symbol, 6, operands.len())?; - let gamma = operands[0]; - let gamma2 = gamma.square(); - let gamma3 = gamma2 * gamma; - let gamma4 = gamma2.square(); - Ok(operands[1] - + gamma * operands[2] - + gamma2 * operands[3] - + gamma3 * operands[4] - + gamma4 * operands[5]) - } - "field.add" => { - require_operand_count(expr.symbol, 2, operands.len())?; - Ok(operands[0] + operands[1]) - } - "field.sub" => { - require_operand_count(expr.symbol, 2, operands.len())?; - Ok(operands[0] - operands[1]) - } - "field.mul" => { - require_operand_count(expr.symbol, 2, operands.len())?; - Ok(operands[0] * operands[1]) - } - "field.neg" => { - require_operand_count(expr.symbol, 1, operands.len())?; - Ok(-operands[0]) - } - formula => { - if let Some(exponent) = formula.strip_prefix("field.pow:") { - require_operand_count(expr.symbol, 1, operands.len())?; - let exponent = exponent.parse::().map_err(|_| { - VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - } - })?; - return Ok(pow_field(operands[0], exponent)); - } - if let Some(spec) = formula.strip_prefix("poly.lagrange_basis_eval:") { - require_operand_count(expr.symbol, 1, operands.len())?; - let parts = spec.split(':').collect::>(); - if parts.len() != 3 { - return Err(VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - }); - } - let domain_start = parts[0].parse::().map_err(|_| { - VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - } - })?; - let domain_size = parts[1].parse::().map_err(|_| { - VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - } - })?; - let index = parts[2].parse::().map_err(|_| { - VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - } - })?; - let weights = lagrange_evals(domain_start, domain_size, operands[0]); - return weights - .get(index) - .copied() - .ok_or(VerifyStage2Error::InvalidInputLength { - input: expr.symbol, - expected: index + 1, - actual: weights.len(), - }); - } - Err(VerifyStage2Error::UnsupportedFieldExpr { - symbol: expr.symbol, - formula, - }) - } - } -} - fn expected_batched_output_claim( program: &'static Stage2VerifierProgramPlan, driver: &'static Stage2SumcheckDriverPlan, @@ -771,15 +665,19 @@ fn expected_batched_output_claim( actual: point.len(), })?; let value = match instance.relation { - "jolt.stage2.ram.read_write" => expected_ram_read_write(store, evals, local_point)?, - "jolt.stage2.product_virtual.remainder" => { + Stage2RelationKind::Stage2RamReadWrite => { + expected_ram_read_write(store, evals, local_point)? + } + Stage2RelationKind::Stage2ProductVirtualRemainder => { expected_product_remainder(store, evals, local_point)? } - "jolt.stage2.instruction_lookup.claim_reduction" => { + Stage2RelationKind::Stage2InstructionLookupClaimReduction => { expected_instruction_lookup(store, evals, local_point)? } - "jolt.stage2.ram.raf_evaluation" => expected_ram_raf(evals, local_point, ram)?, - "jolt.stage2.ram.output_check" => expected_ram_output(store, evals, local_point, ram)?, + Stage2RelationKind::Stage2RamRafEvaluation => expected_ram_raf(evals, local_point, ram)?, + Stage2RelationKind::Stage2RamOutputCheck => { + expected_ram_output(store, evals, local_point, ram)? + } relation => return Err(VerifyStage2Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index d22851483a..3e114db8c8 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -17,14 +17,19 @@ pub type Stage3OpeningInputValue = super::common::StageOpeningInputValue; pub type Stage3VerifierProgramPlan = super::common::StageVerifierProgramPlan; pub use super::common::{ - FieldConstantPlan as Stage3FieldConstantPlan, FieldExprPlan as Stage3FieldExprPlan, + ClaimKind as Stage3ClaimKind, RelationKind as Stage3RelationKind, FieldConstantPlan as Stage3FieldConstantPlan, + FieldExprKind as Stage3FieldExprKind, + FieldExprPlan as Stage3FieldExprPlan, OpeningBatchPlan as Stage3OpeningBatchPlan, OpeningClaimEqualityPlan as Stage3OpeningClaimEqualityPlan, OpeningClaimPlan as Stage3OpeningClaimPlan, OpeningInputPlan as Stage3OpeningInputPlan, PointConcatPlan as Stage3PointConcatPlan, PointSlicePlan as Stage3PointSlicePlan, - ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, + OpeningEqualityMode as Stage3OpeningEqualityMode, + ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, + StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage3SumcheckInstanceResultPlan, + TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, SumcheckClaimPlan as Stage3SumcheckClaimPlan, SumcheckDriverPlan as Stage3SumcheckDriverPlan, @@ -39,44 +44,39 @@ pub enum VerifyStage3Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage3RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); -pub const STAGE3_PARAMS: Stage3Params = Stage3Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE3_PARAMS: Stage3Params = Stage3Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[ - Stage3ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage3.spartan_shift.gamma" }, - Stage3ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage3.instruction_input.gamma" }, - Stage3ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage3.registers.gamma" }, - Stage3ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage3.sumcheck" }, + Stage3ProgramStepPlan { kind: Stage3ProgramStepKind::TranscriptSqueeze, symbol: "stage3.spartan_shift.gamma" }, + Stage3ProgramStepPlan { kind: Stage3ProgramStepKind::TranscriptSqueeze, symbol: "stage3.instruction_input.gamma" }, + Stage3ProgramStepPlan { kind: Stage3ProgramStepKind::TranscriptSqueeze, symbol: "stage3.registers.gamma" }, + Stage3ProgramStepPlan { kind: Stage3ProgramStepKind::SumcheckDriver, symbol: "stage3.sumcheck" }, ]; pub const STAGE3_TRANSCRIPT_SQUEEZES: &[Stage3TranscriptSqueezePlan] = &[ - Stage3TranscriptSqueezePlan { symbol: "stage3.spartan_shift.gamma", label: "spartan_shift_gamma", kind: "challenge_scalar", count: 1 }, - Stage3TranscriptSqueezePlan { symbol: "stage3.instruction_input.gamma", label: "instruction_input_gamma", kind: "challenge_scalar", count: 1 }, - Stage3TranscriptSqueezePlan { symbol: "stage3.registers.gamma", label: "registers_gamma", kind: "challenge_scalar", count: 1 }, + Stage3TranscriptSqueezePlan { symbol: "stage3.spartan_shift.gamma", label: "spartan_shift_gamma", kind: Stage3TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage3TranscriptSqueezePlan { symbol: "stage3.instruction_input.gamma", label: "instruction_input_gamma", kind: Stage3TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage3TranscriptSqueezePlan { symbol: "stage3.registers.gamma", label: "registers_gamma", kind: Stage3TranscriptSqueezeKind::ChallengeScalar, count: 1 }, ]; pub const STAGE3_OPENING_INPUTS: &[Stage3OpeningInputPlan] = &[ - Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextUnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextUnexpandedPC", oracle: "NextUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextPC", oracle: "NextPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextIsVirtual", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextIsVirtual", oracle: "NextIsVirtual", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextIsFirstInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextIsFirstInSequence", oracle: "NextIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.NextIsNoop", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.NextIsNoop", oracle: "NextIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.LeftInstructionInput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.RightInstructionInput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage2.instruction_lookup.LeftInstructionInput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage2.instruction_lookup.RightInstructionInput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage1.RdWriteValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage1.Rs1Value", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage3OpeningInputPlan { symbol: "stage3.input.stage1.Rs2Value", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextUnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextUnexpandedPC", oracle: "NextUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextPC", oracle: "NextPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextIsVirtual", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextIsVirtual", oracle: "NextIsVirtual", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage1.NextIsFirstInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.NextIsFirstInSequence", oracle: "NextIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.NextIsNoop", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.NextIsNoop", oracle: "NextIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.LeftInstructionInput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage2.product_virtual.RightInstructionInput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage2.instruction_lookup.LeftInstructionInput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", oracle: "LeftInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage2.instruction_lookup.RightInstructionInput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", oracle: "RightInstructionInput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage1.RdWriteValue", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage1.Rs1Value", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, + Stage3OpeningInputPlan { symbol: "stage3.input.stage1.Rs2Value", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual }, ]; pub const STAGE3_FIELD_CONSTANTS: &[Stage3FieldConstantPlan] = &[ @@ -84,49 +84,45 @@ pub const STAGE3_FIELD_CONSTANTS: &[Stage3FieldConstantPlan] = &[ ]; pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[ - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma2", kind: "op", formula: "field.pow:2", operands: "stage3.spartan_shift.gamma" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma3", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma2|stage3.spartan_shift.gamma" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma4", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma2|stage3.spartan_shift.gamma2" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextPC", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma|stage3.input.stage1.NextPC" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsVirtual", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma2|stage3.input.stage1.NextIsVirtual" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsFirstInSequence", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma3|stage3.input.stage1.NextIsFirstInSequence" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.one_minus.NextIsNoop", kind: "op", formula: "field.sub", operands: "stage3.field.one|stage3.input.stage2.product_virtual.NextIsNoop" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsNoop", kind: "op", formula: "field.mul", operands: "stage3.spartan_shift.gamma4|stage3.spartan_shift.one_minus.NextIsNoop" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextUnexpandedPCNextPC", kind: "op", formula: "field.add", operands: "stage3.input.stage1.NextUnexpandedPC|stage3.spartan_shift.term.NextPC" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsVirtual", kind: "op", formula: "field.add", operands: "stage3.spartan_shift.partial.NextUnexpandedPCNextPC|stage3.spartan_shift.term.NextIsVirtual" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsFirstInSequence", kind: "op", formula: "field.add", operands: "stage3.spartan_shift.partial.NextIsVirtual|stage3.spartan_shift.term.NextIsFirstInSequence" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.claim_expr", kind: "op", formula: "field.add", operands: "stage3.spartan_shift.partial.NextIsFirstInSequence|stage3.spartan_shift.term.NextIsNoop" }, - Stage3FieldExprPlan { symbol: "stage3.instruction_input.term.LeftInstructionInput", kind: "op", formula: "field.mul", operands: "stage3.instruction_input.gamma|stage3.input.stage2.product_virtual.LeftInstructionInput" }, - Stage3FieldExprPlan { symbol: "stage3.instruction_input.claim_expr", kind: "op", formula: "field.add", operands: "stage3.input.stage2.product_virtual.RightInstructionInput|stage3.instruction_input.term.LeftInstructionInput" }, - Stage3FieldExprPlan { symbol: "stage3.registers.gamma2", kind: "op", formula: "field.pow:2", operands: "stage3.registers.gamma" }, - Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs1Value", kind: "op", formula: "field.mul", operands: "stage3.registers.gamma|stage3.input.stage1.Rs1Value" }, - Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs2Value", kind: "op", formula: "field.mul", operands: "stage3.registers.gamma2|stage3.input.stage1.Rs2Value" }, - Stage3FieldExprPlan { symbol: "stage3.registers.partial.RdWriteValueRs1Value", kind: "op", formula: "field.add", operands: "stage3.input.stage1.RdWriteValue|stage3.registers.term.Rs1Value" }, - Stage3FieldExprPlan { symbol: "stage3.registers.claim_expr", kind: "op", formula: "field.add", operands: "stage3.registers.partial.RdWriteValueRs1Value|stage3.registers.term.Rs2Value" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma2", kind: Stage3FieldExprKind::Pow(2), operands: "stage3.spartan_shift.gamma" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma3", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma2|stage3.spartan_shift.gamma" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma4", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma2|stage3.spartan_shift.gamma2" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextPC", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma|stage3.input.stage1.NextPC" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsVirtual", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma2|stage3.input.stage1.NextIsVirtual" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsFirstInSequence", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma3|stage3.input.stage1.NextIsFirstInSequence" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.one_minus.NextIsNoop", kind: Stage3FieldExprKind::Sub, operands: "stage3.field.one|stage3.input.stage2.product_virtual.NextIsNoop" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsNoop", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma4|stage3.spartan_shift.one_minus.NextIsNoop" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextUnexpandedPCNextPC", kind: Stage3FieldExprKind::Add, operands: "stage3.input.stage1.NextUnexpandedPC|stage3.spartan_shift.term.NextPC" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsVirtual", kind: Stage3FieldExprKind::Add, operands: "stage3.spartan_shift.partial.NextUnexpandedPCNextPC|stage3.spartan_shift.term.NextIsVirtual" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsFirstInSequence", kind: Stage3FieldExprKind::Add, operands: "stage3.spartan_shift.partial.NextIsVirtual|stage3.spartan_shift.term.NextIsFirstInSequence" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.claim_expr", kind: Stage3FieldExprKind::Add, operands: "stage3.spartan_shift.partial.NextIsFirstInSequence|stage3.spartan_shift.term.NextIsNoop" }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.term.LeftInstructionInput", kind: Stage3FieldExprKind::Mul, operands: "stage3.instruction_input.gamma|stage3.input.stage2.product_virtual.LeftInstructionInput" }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.claim_expr", kind: Stage3FieldExprKind::Add, operands: "stage3.input.stage2.product_virtual.RightInstructionInput|stage3.instruction_input.term.LeftInstructionInput" }, + Stage3FieldExprPlan { symbol: "stage3.registers.gamma2", kind: Stage3FieldExprKind::Pow(2), operands: "stage3.registers.gamma" }, + Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs1Value", kind: Stage3FieldExprKind::Mul, operands: "stage3.registers.gamma|stage3.input.stage1.Rs1Value" }, + Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs2Value", kind: Stage3FieldExprKind::Mul, operands: "stage3.registers.gamma2|stage3.input.stage1.Rs2Value" }, + Stage3FieldExprPlan { symbol: "stage3.registers.partial.RdWriteValueRs1Value", kind: Stage3FieldExprKind::Add, operands: "stage3.input.stage1.RdWriteValue|stage3.registers.term.Rs1Value" }, + Stage3FieldExprPlan { symbol: "stage3.registers.claim_expr", kind: Stage3FieldExprKind::Add, operands: "stage3.registers.partial.RdWriteValueRs1Value|stage3.registers.term.Rs2Value" }, ]; pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[ - Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some("jolt.stage3.spartan_shift"), claim_value: "stage3.spartan_shift.claim_expr", input_openings: "stage3.input.stage1.NextUnexpandedPC|stage3.input.stage1.NextPC|stage3.input.stage1.NextIsVirtual|stage3.input.stage1.NextIsFirstInSequence|stage3.input.stage2.product_virtual.NextIsNoop" }, - Stage3SumcheckClaimPlan { symbol: "stage3.instruction_input.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage3.instruction_input.weighted_inputs", kernel: None, relation: Some("jolt.stage3.instruction_input"), claim_value: "stage3.instruction_input.claim_expr", input_openings: "stage3.input.stage2.product_virtual.RightInstructionInput|stage3.input.stage2.product_virtual.LeftInstructionInput" }, - Stage3SumcheckClaimPlan { symbol: "stage3.registers_claim_reduction.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.registers.weighted_register_values", kernel: None, relation: Some("jolt.stage3.registers_claim_reduction"), claim_value: "stage3.registers.claim_expr", input_openings: "stage3.input.stage1.RdWriteValue|stage3.input.stage1.Rs1Value|stage3.input.stage1.Rs2Value" }, -]; -pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 16, + Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr", input_openings: "stage3.input.stage1.NextUnexpandedPC|stage3.input.stage1.NextPC|stage3.input.stage1.NextIsVirtual|stage3.input.stage1.NextIsFirstInSequence|stage3.input.stage2.product_virtual.NextIsNoop" }, + Stage3SumcheckClaimPlan { symbol: "stage3.instruction_input.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage3.instruction_input.weighted_inputs", kernel: None, relation: Some(Stage3RelationKind::Stage3InstructionInput), claim_value: "stage3.instruction_input.claim_expr", input_openings: "stage3.input.stage2.product_virtual.RightInstructionInput|stage3.input.stage2.product_virtual.LeftInstructionInput" }, + Stage3SumcheckClaimPlan { symbol: "stage3.registers_claim_reduction.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.registers.weighted_register_values", kernel: None, relation: Some(Stage3RelationKind::Stage3RegistersClaimReduction), claim_value: "stage3.registers.claim_expr", input_openings: "stage3.input.stage1.RdWriteValue|stage3.input.stage1.Rs1Value|stage3.input.stage1.Rs2Value" }, ]; +pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16]; pub const STAGE3_SUMCHECK_BATCHES: &[Stage3SumcheckBatchPlan] = &[ Stage3SumcheckBatchPlan { symbol: "stage3.batch", stage: "stage3", proof_slot: "stage3.sumcheck", policy: "jolt_core_stage3_aligned", count: 3, ordered_claims: "stage3.spartan_shift.input|stage3.instruction_input.input|stage3.registers_claim_reduction.input", claim_operands: "stage3.spartan_shift.input|stage3.instruction_input.input|stage3.registers_claim_reduction.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; -pub const STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 16, -]; +pub const STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16]; pub const STAGE3_SUMCHECK_DRIVERS: &[Stage3SumcheckDriverPlan] = &[ - Stage3SumcheckDriverPlan { symbol: "stage3.sumcheck", stage: "stage3", proof_slot: "stage3.sumcheck", kernel: None, relation: Some("jolt.stage3.batched"), batch: "stage3.batch", policy: "jolt_core_stage3_aligned", round_schedule: STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 16, degree: 3 }, + Stage3SumcheckDriverPlan { symbol: "stage3.sumcheck", stage: "stage3", proof_slot: "stage3.sumcheck", kernel: None, relation: Some(Stage3RelationKind::Stage3Batched), batch: "stage3.batch", policy: "jolt_core_stage3_aligned", round_schedule: STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 16, degree: 3 }, ]; pub const STAGE3_SUMCHECK_INSTANCE_RESULTS: &[Stage3SumcheckInstanceResultPlan] = &[ - Stage3SumcheckInstanceResultPlan { symbol: "stage3.spartan_shift.instance", source: "stage3.sumcheck", claim: "stage3.spartan_shift.input", relation: "jolt.stage3.spartan_shift", index: 0, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 2 }, - Stage3SumcheckInstanceResultPlan { symbol: "stage3.instruction_input.instance", source: "stage3.sumcheck", claim: "stage3.instruction_input.input", relation: "jolt.stage3.instruction_input", index: 1, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 3 }, - Stage3SumcheckInstanceResultPlan { symbol: "stage3.registers_claim_reduction.instance", source: "stage3.sumcheck", claim: "stage3.registers_claim_reduction.input", relation: "jolt.stage3.registers_claim_reduction", index: 2, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 2 }, + Stage3SumcheckInstanceResultPlan { symbol: "stage3.spartan_shift.instance", source: "stage3.sumcheck", claim: "stage3.spartan_shift.input", relation: Stage3RelationKind::Stage3SpartanShift, index: 0, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 2 }, + Stage3SumcheckInstanceResultPlan { symbol: "stage3.instruction_input.instance", source: "stage3.sumcheck", claim: "stage3.instruction_input.input", relation: Stage3RelationKind::Stage3InstructionInput, index: 1, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 3 }, + Stage3SumcheckInstanceResultPlan { symbol: "stage3.registers_claim_reduction.instance", source: "stage3.sumcheck", claim: "stage3.registers_claim_reduction.input", relation: Stage3RelationKind::Stage3RegistersClaimReduction, index: 2, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 2 }, ]; pub const STAGE3_SUMCHECK_EVALS: &[Stage3SumcheckEvalPlan] = &[ @@ -156,27 +152,27 @@ pub const STAGE3_POINT_CONCATS: &[Stage3PointConcatPlan] = &[ ]; pub const STAGE3_OPENING_CLAIMS: &[Stage3OpeningClaimPlan] = &[ - Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.UnexpandedPC" }, - Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.PC" }, - Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.OpFlagVirtualInstruction" }, - Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.OpFlagIsFirstInSequence" }, - Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.InstructionFlagIsNoop", oracle: "InstructionFlagIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.InstructionFlagIsNoop" }, - Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", oracle: "InstructionFlagLeftOperandIsRs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value" }, - Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Rs1Value" }, - Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", oracle: "InstructionFlagLeftOperandIsPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC" }, - Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.UnexpandedPC" }, - Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", oracle: "InstructionFlagRightOperandIsRs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value" }, - Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Rs2Value" }, - Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", oracle: "InstructionFlagRightOperandIsImm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm" }, - Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Imm" }, - Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.RdWriteValue" }, - Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.Rs1Value" }, - Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.Rs2Value" }, + Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.UnexpandedPC" }, + Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.PC" }, + Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.OpFlagVirtualInstruction" }, + Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.OpFlagIsFirstInSequence" }, + Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.InstructionFlagIsNoop", oracle: "InstructionFlagIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.InstructionFlagIsNoop" }, + Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", oracle: "InstructionFlagLeftOperandIsRs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value" }, + Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Rs1Value" }, + Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", oracle: "InstructionFlagLeftOperandIsPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC" }, + Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.UnexpandedPC" }, + Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", oracle: "InstructionFlagRightOperandIsRs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value" }, + Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Rs2Value" }, + Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", oracle: "InstructionFlagRightOperandIsImm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm" }, + Stage3OpeningClaimPlan { symbol: "stage3.instruction_input.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.instruction_input.instance", eval_source: "stage3.instruction_input.eval.Imm" }, + Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.RdWriteValue" }, + Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.Rs1Value" }, + Stage3OpeningClaimPlan { symbol: "stage3.registers_claim_reduction.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.registers_claim_reduction.instance", eval_source: "stage3.registers_claim_reduction.eval.Rs2Value" }, ]; pub const STAGE3_OPENING_EQUALITIES: &[Stage3OpeningClaimEqualityPlan] = &[ - Stage3OpeningClaimEqualityPlan { symbol: "stage3.instruction_input.left_claim_consistency", mode: "point_and_eval", lhs: "stage3.input.stage2.product_virtual.LeftInstructionInput", rhs: "stage3.input.stage2.instruction_lookup.LeftInstructionInput" }, - Stage3OpeningClaimEqualityPlan { symbol: "stage3.instruction_input.right_claim_consistency", mode: "point_and_eval", lhs: "stage3.input.stage2.product_virtual.RightInstructionInput", rhs: "stage3.input.stage2.instruction_lookup.RightInstructionInput" }, + Stage3OpeningClaimEqualityPlan { symbol: "stage3.instruction_input.left_claim_consistency", mode: Stage3OpeningEqualityMode::PointAndEval, lhs: "stage3.input.stage2.product_virtual.LeftInstructionInput", rhs: "stage3.input.stage2.instruction_lookup.LeftInstructionInput" }, + Stage3OpeningClaimEqualityPlan { symbol: "stage3.instruction_input.right_claim_consistency", mode: Stage3OpeningEqualityMode::PointAndEval, lhs: "stage3.input.stage2.product_virtual.RightInstructionInput", rhs: "stage3.input.stage2.instruction_lookup.RightInstructionInput" }, ]; pub const STAGE3_OPENING_BATCHES: &[Stage3OpeningBatchPlan] = &[ @@ -233,21 +229,21 @@ where let mut artifacts = Stage3ExecutionArtifacts::default(); for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage3ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage3Error::MissingValue { symbol: step.symbol, })?; verify_stage3_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "sumcheck_driver" => { + Stage3ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage3Error::MissingProof { driver: step.symbol, })?; verify_stage3_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?; } - _ => { + Stage3ProgramStepKind::TranscriptAbsorbBytes => { return Err(VerifyStage3Error::InvalidProof { driver: step.symbol, reason: "unsupported stage3 program step", @@ -310,16 +306,17 @@ where .ok_or(VerifyStage3Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage3Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage3.batched" => { + Stage3RelationKind::Stage3Batched => { verify_batched_stage3(program, driver, proof, store, transcript)? } - _ => { - return Err(VerifyStage3Error::UnsupportedRelation { - relation, - }); - } + relation => return Err(VerifyStage3Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); Ok(()) @@ -430,20 +427,16 @@ fn expected_batched_output_claim( actual: point.len(), })?; let value = match instance.relation { - "jolt.stage3.spartan_shift" => { + Stage3RelationKind::Stage3SpartanShift => { expected_spartan_shift(store, evals, local_point)? } - "jolt.stage3.instruction_input" => { + Stage3RelationKind::Stage3InstructionInput => { expected_instruction_input(store, evals, local_point)? } - "jolt.stage3.registers_claim_reduction" => { + Stage3RelationKind::Stage3RegistersClaimReduction => { expected_registers(store, evals, local_point)? } - _ => { - return Err(VerifyStage3Error::UnsupportedRelation { - relation: instance.relation, - }); - } + relation => return Err(VerifyStage3Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; } diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 3367e34d96..182ff0accb 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -14,11 +14,15 @@ pub type Stage4Proof = super::common::StageProof; pub type Stage4OpeningInputValue = super::common::StageOpeningInputValue; pub use super::common::{ - FieldConstantPlan as Stage4FieldConstantPlan, FieldExprPlan as Stage4FieldExprPlan, + ClaimKind as Stage4ClaimKind, RelationKind as Stage4RelationKind, FieldConstantPlan as Stage4FieldConstantPlan, + FieldExprKind as Stage4FieldExprKind, + FieldExprPlan as Stage4FieldExprPlan, KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan, OpeningClaimEqualityPlan as Stage4OpeningClaimEqualityPlan, OpeningClaimPlan as Stage4OpeningClaimPlan, OpeningInputPlan as Stage4OpeningInputPlan, + OpeningEqualityMode as Stage4OpeningEqualityMode, PointConcatPlan as Stage4PointConcatPlan, PointSlicePlan as Stage4PointSlicePlan, + ProgramStepKind as Stage4ProgramStepKind, ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, StageProgramPlanNoPointZeros as Stage4CpuProgramPlan, SumcheckBatchPlan as Stage4SumcheckBatchPlan, @@ -26,6 +30,7 @@ pub use super::common::{ SumcheckEvalPlan as Stage4SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage4SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan, + TranscriptSqueezeKind as Stage4TranscriptSqueezeKind, TranscriptSqueezePlan as Stage4TranscriptSqueezePlan, }; @@ -41,28 +46,23 @@ pub enum VerifyStage4Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage4RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); -pub const STAGE4_PARAMS: Stage4Params = Stage4Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE4_PARAMS: Stage4Params = Stage4Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE4_PROGRAM_STEPS: &[Stage4ProgramStepPlan] = &[ - Stage4ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage4.registers_read_write.gamma" }, - Stage4ProgramStepPlan { kind: "transcript_absorb_bytes", symbol: "stage4.ram_val_check.domain_separator" }, - Stage4ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage4.ram_val_check.gamma" }, - Stage4ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage4.sumcheck" }, + Stage4ProgramStepPlan { kind: Stage4ProgramStepKind::TranscriptSqueeze, symbol: "stage4.registers_read_write.gamma" }, + Stage4ProgramStepPlan { kind: Stage4ProgramStepKind::TranscriptAbsorbBytes, symbol: "stage4.ram_val_check.domain_separator" }, + Stage4ProgramStepPlan { kind: Stage4ProgramStepKind::TranscriptSqueeze, symbol: "stage4.ram_val_check.gamma" }, + Stage4ProgramStepPlan { kind: Stage4ProgramStepKind::SumcheckDriver, symbol: "stage4.sumcheck" }, ]; pub const STAGE4_TRANSCRIPT_SQUEEZES: &[Stage4TranscriptSqueezePlan] = &[ - Stage4TranscriptSqueezePlan { symbol: "stage4.registers_read_write.gamma", label: "registers_read_write_gamma", kind: "challenge_scalar", count: 1 }, - Stage4TranscriptSqueezePlan { symbol: "stage4.ram_val_check.gamma", label: "ram_val_check_gamma", kind: "challenge_scalar", count: 1 }, + Stage4TranscriptSqueezePlan { symbol: "stage4.registers_read_write.gamma", label: "registers_read_write_gamma", kind: Stage4TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage4TranscriptSqueezePlan { symbol: "stage4.ram_val_check.gamma", label: "ram_val_check_gamma", kind: Stage4TranscriptSqueezeKind::ChallengeScalar, count: 1 }, ]; pub const STAGE4_TRANSCRIPT_ABSORB_BYTES: &[Stage4TranscriptAbsorbBytesPlan] = &[ @@ -70,14 +70,14 @@ pub const STAGE4_TRANSCRIPT_ABSORB_BYTES: &[Stage4TranscriptAbsorbBytesPlan] = & ]; pub const STAGE4_OPENING_INPUTS: &[Stage4OpeningInputPlan] = &[ - Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.RdWriteValue", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.Rs1Value", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.Rs2Value", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage4OpeningInputPlan { symbol: "stage4.input.stage3.instruction.Rs1Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage4OpeningInputPlan { symbol: "stage4.input.stage3.instruction.Rs2Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage4OpeningInputPlan { symbol: "stage4.input.stage2.RamVal", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamVal", oracle: "RamVal", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual" }, - Stage4OpeningInputPlan { symbol: "stage4.input.stage2.RamValFinal", source_stage: "stage2", source_claim: "stage2.ram_output.opening.RamValFinal", oracle: "RamValFinal", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: "virtual" }, - Stage4OpeningInputPlan { symbol: "stage4.input.initial_ram.RamValInit", source_stage: "stage4_precomputed", source_claim: "stage4.ram_val_check.initial_ram_eval", oracle: "RamValInit", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: "virtual" }, + Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.RdWriteValue", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.RdWriteValue", oracle: "RdWriteValue", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual }, + Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.Rs1Value", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual }, + Stage4OpeningInputPlan { symbol: "stage4.input.stage3.registers.Rs2Value", source_stage: "stage3", source_claim: "stage3.registers_claim_reduction.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual }, + Stage4OpeningInputPlan { symbol: "stage4.input.stage3.instruction.Rs1Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Rs1Value", oracle: "Rs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual }, + Stage4OpeningInputPlan { symbol: "stage4.input.stage3.instruction.Rs2Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Rs2Value", oracle: "Rs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual }, + Stage4OpeningInputPlan { symbol: "stage4.input.stage2.RamVal", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamVal", oracle: "RamVal", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage4ClaimKind::Virtual }, + Stage4OpeningInputPlan { symbol: "stage4.input.stage2.RamValFinal", source_stage: "stage2", source_claim: "stage2.ram_output.opening.RamValFinal", oracle: "RamValFinal", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual }, + Stage4OpeningInputPlan { symbol: "stage4.input.initial_ram.RamValInit", source_stage: "stage4_precomputed", source_claim: "stage4.ram_val_check.initial_ram_eval", oracle: "RamValInit", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Virtual }, ]; pub const STAGE4_FIELD_CONSTANTS: &[Stage4FieldConstantPlan] = &[ @@ -85,43 +85,37 @@ pub const STAGE4_FIELD_CONSTANTS: &[Stage4FieldConstantPlan] = &[ ]; pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[ - Stage4FieldExprPlan { symbol: "stage4.registers_read_write.gamma2", kind: "op", formula: "field.pow:2", operands: "stage4.registers_read_write.gamma" }, - Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs1Value", kind: "op", formula: "field.mul", operands: "stage4.registers_read_write.gamma|stage4.input.stage3.registers.Rs1Value" }, - Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs2Value", kind: "op", formula: "field.mul", operands: "stage4.registers_read_write.gamma2|stage4.input.stage3.registers.Rs2Value" }, - Stage4FieldExprPlan { symbol: "stage4.registers_read_write.partial.RdWriteValueRs1Value", kind: "op", formula: "field.add", operands: "stage4.input.stage3.registers.RdWriteValue|stage4.registers_read_write.term.Rs1Value" }, - Stage4FieldExprPlan { symbol: "stage4.registers_read_write.claim_expr", kind: "op", formula: "field.add", operands: "stage4.registers_read_write.partial.RdWriteValueRs1Value|stage4.registers_read_write.term.Rs2Value" }, - Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamVal", kind: "op", formula: "field.sub", operands: "stage4.input.stage2.RamVal|stage4.input.initial_ram.RamValInit" }, - Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamValFinal", kind: "op", formula: "field.sub", operands: "stage4.input.stage2.RamValFinal|stage4.input.initial_ram.RamValInit" }, - Stage4FieldExprPlan { symbol: "stage4.ram_val_check.term.RamValFinal", kind: "op", formula: "field.mul", operands: "stage4.ram_val_check.gamma|stage4.ram_val_check.delta.RamValFinal" }, - Stage4FieldExprPlan { symbol: "stage4.ram_val_check.claim_expr", kind: "op", formula: "field.add", operands: "stage4.ram_val_check.delta.RamVal|stage4.ram_val_check.term.RamValFinal" }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.gamma2", kind: Stage4FieldExprKind::Pow(2), operands: "stage4.registers_read_write.gamma" }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs1Value", kind: Stage4FieldExprKind::Mul, operands: "stage4.registers_read_write.gamma|stage4.input.stage3.registers.Rs1Value" }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs2Value", kind: Stage4FieldExprKind::Mul, operands: "stage4.registers_read_write.gamma2|stage4.input.stage3.registers.Rs2Value" }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.partial.RdWriteValueRs1Value", kind: Stage4FieldExprKind::Add, operands: "stage4.input.stage3.registers.RdWriteValue|stage4.registers_read_write.term.Rs1Value" }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.claim_expr", kind: Stage4FieldExprKind::Add, operands: "stage4.registers_read_write.partial.RdWriteValueRs1Value|stage4.registers_read_write.term.Rs2Value" }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamVal", kind: Stage4FieldExprKind::Sub, operands: "stage4.input.stage2.RamVal|stage4.input.initial_ram.RamValInit" }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamValFinal", kind: Stage4FieldExprKind::Sub, operands: "stage4.input.stage2.RamValFinal|stage4.input.initial_ram.RamValInit" }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.term.RamValFinal", kind: Stage4FieldExprKind::Mul, operands: "stage4.ram_val_check.gamma|stage4.ram_val_check.delta.RamValFinal" }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.claim_expr", kind: Stage4FieldExprKind::Add, operands: "stage4.ram_val_check.delta.RamVal|stage4.ram_val_check.term.RamValFinal" }, ]; pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[ ]; pub const STAGE4_SUMCHECK_CLAIMS: &[Stage4SumcheckClaimPlan] = &[ - Stage4SumcheckClaimPlan { symbol: "stage4.registers_read_write.input", stage: "stage4", domain: "jolt.stage4_registers_rw_domain", num_rounds: 23, degree: 3, claim: "stage4.registers_read_write.weighted_values", kernel: None, relation: Some("jolt.stage4.registers_read_write"), claim_value: "stage4.registers_read_write.claim_expr", input_openings: "stage4.input.stage3.registers.RdWriteValue|stage4.input.stage3.registers.Rs1Value|stage4.input.stage3.registers.Rs2Value" }, - Stage4SumcheckClaimPlan { symbol: "stage4.ram_val_check.input", stage: "stage4", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage4.ram_val_check.weighted_values", kernel: None, relation: Some("jolt.stage4.ram_val_check"), claim_value: "stage4.ram_val_check.claim_expr", input_openings: "stage4.input.stage2.RamVal|stage4.input.stage2.RamValFinal|stage4.input.initial_ram.RamValInit" }, -]; -pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 16, - 7, + Stage4SumcheckClaimPlan { symbol: "stage4.registers_read_write.input", stage: "stage4", domain: "jolt.stage4_registers_rw_domain", num_rounds: 23, degree: 3, claim: "stage4.registers_read_write.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RegistersReadWrite), claim_value: "stage4.registers_read_write.claim_expr", input_openings: "stage4.input.stage3.registers.RdWriteValue|stage4.input.stage3.registers.Rs1Value|stage4.input.stage3.registers.Rs2Value" }, + Stage4SumcheckClaimPlan { symbol: "stage4.ram_val_check.input", stage: "stage4", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage4.ram_val_check.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RamValCheck), claim_value: "stage4.ram_val_check.claim_expr", input_openings: "stage4.input.stage2.RamVal|stage4.input.stage2.RamValFinal|stage4.input.initial_ram.RamValInit" }, ]; +pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16, 7]; pub const STAGE4_SUMCHECK_BATCHES: &[Stage4SumcheckBatchPlan] = &[ Stage4SumcheckBatchPlan { symbol: "stage4.batch", stage: "stage4", proof_slot: "stage4.sumcheck", policy: "jolt_core_stage4_aligned", count: 2, ordered_claims: "stage4.registers_read_write.input|stage4.ram_val_check.input", claim_operands: "stage4.registers_read_write.input|stage4.ram_val_check.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; -pub const STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 16, - 7, -]; +pub const STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16, 7]; pub const STAGE4_SUMCHECK_DRIVERS: &[Stage4SumcheckDriverPlan] = &[ - Stage4SumcheckDriverPlan { symbol: "stage4.sumcheck", stage: "stage4", proof_slot: "stage4.sumcheck", kernel: None, relation: Some("jolt.stage4.batched"), batch: "stage4.batch", policy: "jolt_core_stage4_aligned", round_schedule: STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 23, degree: 3 }, + Stage4SumcheckDriverPlan { symbol: "stage4.sumcheck", stage: "stage4", proof_slot: "stage4.sumcheck", kernel: None, relation: Some(Stage4RelationKind::Stage4Batched), batch: "stage4.batch", policy: "jolt_core_stage4_aligned", round_schedule: STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 23, degree: 3 }, ]; pub const STAGE4_SUMCHECK_INSTANCE_RESULTS: &[Stage4SumcheckInstanceResultPlan] = &[ - Stage4SumcheckInstanceResultPlan { symbol: "stage4.registers_read_write.instance", source: "stage4.sumcheck", claim: "stage4.registers_read_write.input", relation: "jolt.stage4.registers_read_write", index: 0, point_arity: 23, num_rounds: 23, round_offset: 0, point_order: "stage4_registers_rw", degree: 3 }, - Stage4SumcheckInstanceResultPlan { symbol: "stage4.ram_val_check.instance", source: "stage4.sumcheck", claim: "stage4.ram_val_check.input", relation: "jolt.stage4.ram_val_check", index: 1, point_arity: 16, num_rounds: 16, round_offset: 7, point_order: "reverse", degree: 3 }, + Stage4SumcheckInstanceResultPlan { symbol: "stage4.registers_read_write.instance", source: "stage4.sumcheck", claim: "stage4.registers_read_write.input", relation: Stage4RelationKind::Stage4RegistersReadWrite, index: 0, point_arity: 23, num_rounds: 23, round_offset: 0, point_order: "stage4_registers_rw", degree: 3 }, + Stage4SumcheckInstanceResultPlan { symbol: "stage4.ram_val_check.instance", source: "stage4.sumcheck", claim: "stage4.ram_val_check.input", relation: Stage4RelationKind::Stage4RamValCheck, index: 1, point_arity: 16, num_rounds: 16, round_offset: 7, point_order: "reverse", degree: 3 }, ]; pub const STAGE4_SUMCHECK_EVALS: &[Stage4SumcheckEvalPlan] = &[ @@ -143,18 +137,18 @@ pub const STAGE4_POINT_CONCATS: &[Stage4PointConcatPlan] = &[ Stage4PointConcatPlan { symbol: "stage4.ram_val_check.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: "stage4.ram_val_check.point.RamAddress|stage4.ram_val_check.instance" }, ]; pub const STAGE4_OPENING_CLAIMS: &[Stage4OpeningClaimPlan] = &[ - Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RegistersVal", oracle: "RegistersVal", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual", point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.RegistersVal" }, - Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.Rs1Ra", oracle: "Rs1Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual", point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.Rs1Ra" }, - Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.Rs2Ra", oracle: "Rs2Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual", point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.Rs2Ra" }, - Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual", point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.RdWa" }, - Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage4.registers_read_write.point.RdInc", eval_source: "stage4.registers_read_write.eval.RdInc" }, - Stage4OpeningClaimPlan { symbol: "stage4.ram_val_check.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage4.ram_val_check.point.RamRa", eval_source: "stage4.ram_val_check.eval.RamRa" }, - Stage4OpeningClaimPlan { symbol: "stage4.ram_val_check.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage4.ram_val_check.instance", eval_source: "stage4.ram_val_check.eval.RamInc" }, + Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RegistersVal", oracle: "RegistersVal", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.RegistersVal" }, + Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.Rs1Ra", oracle: "Rs1Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.Rs1Ra" }, + Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.Rs2Ra", oracle: "Rs2Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.Rs2Ra" }, + Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.RdWa" }, + Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Committed, point_source: "stage4.registers_read_write.point.RdInc", eval_source: "stage4.registers_read_write.eval.RdInc" }, + Stage4OpeningClaimPlan { symbol: "stage4.ram_val_check.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.ram_val_check.point.RamRa", eval_source: "stage4.ram_val_check.eval.RamRa" }, + Stage4OpeningClaimPlan { symbol: "stage4.ram_val_check.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage4ClaimKind::Committed, point_source: "stage4.ram_val_check.instance", eval_source: "stage4.ram_val_check.eval.RamInc" }, ]; pub const STAGE4_OPENING_EQUALITIES: &[Stage4OpeningClaimEqualityPlan] = &[ - Stage4OpeningClaimEqualityPlan { symbol: "stage4.registers.rs1_claim_consistency", mode: "point_and_eval", lhs: "stage4.input.stage3.registers.Rs1Value", rhs: "stage4.input.stage3.instruction.Rs1Value" }, - Stage4OpeningClaimEqualityPlan { symbol: "stage4.registers.rs2_claim_consistency", mode: "point_and_eval", lhs: "stage4.input.stage3.registers.Rs2Value", rhs: "stage4.input.stage3.instruction.Rs2Value" }, + Stage4OpeningClaimEqualityPlan { symbol: "stage4.registers.rs1_claim_consistency", mode: Stage4OpeningEqualityMode::PointAndEval, lhs: "stage4.input.stage3.registers.Rs1Value", rhs: "stage4.input.stage3.instruction.Rs1Value" }, + Stage4OpeningClaimEqualityPlan { symbol: "stage4.registers.rs2_claim_consistency", mode: Stage4OpeningEqualityMode::PointAndEval, lhs: "stage4.input.stage3.registers.Rs2Value", rhs: "stage4.input.stage3.instruction.Rs2Value" }, ]; pub const STAGE4_OPENING_BATCHES: &[Stage4OpeningBatchPlan] = &[ @@ -214,14 +208,14 @@ where let mut artifacts = Stage4ExecutionArtifacts::default(); for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage4ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage4Error::MissingValue { symbol: step.symbol, })?; verify_stage4_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "transcript_absorb_bytes" => { + Stage4ProgramStepKind::TranscriptAbsorbBytes => { let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or( VerifyStage4Error::MissingValue { symbol: step.symbol, @@ -229,19 +223,13 @@ where )?; absorb_stage4_bytes(absorb, transcript); } - "sumcheck_driver" => { + Stage4ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage4Error::MissingProof { driver: step.symbol, })?; verify_stage4_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?; } - _ => { - return Err(VerifyStage4Error::InvalidProof { - driver: step.symbol, - reason: "unsupported stage4 program step", - }); - } } } artifacts @@ -310,12 +298,17 @@ where .ok_or(VerifyStage4Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage4Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage4.batched" => { + Stage4RelationKind::Stage4Batched => { verify_batched_stage4(program, driver, proof, store, transcript)? } - _ => return Err(VerifyStage4Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage4Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); Ok(()) @@ -428,15 +421,20 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let relation = claim.relation.unwrap_or(""); + let Some(relation) = claim.relation else { + return Err(VerifyStage4Error::InvalidProof { + driver: driver.symbol, + reason: "missing claim relation", + }); + }; let value = match relation { - "jolt.stage4.registers_read_write" => { + Stage4RelationKind::Stage4RegistersReadWrite => { expected_registers_read_write(store, evals, local_point)? } - "jolt.stage4.ram_val_check" => { + Stage4RelationKind::Stage4RamValCheck => { expected_ram_val_check(store, evals, local_point)? } - _ => return Err(VerifyStage4Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage4Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; } diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 034d2d9974..fb30946cca 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -15,11 +15,15 @@ pub type Stage5Proof = super::common::StageProof; pub type Stage5OpeningInputValue = super::common::StageOpeningInputValue; pub use super::common::{ - FieldConstantPlan as Stage5FieldConstantPlan, FieldExprPlan as Stage5FieldExprPlan, + ClaimKind as Stage5ClaimKind, RelationKind as Stage5RelationKind, FieldConstantPlan as Stage5FieldConstantPlan, + FieldExprKind as Stage5FieldExprKind, + FieldExprPlan as Stage5FieldExprPlan, KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan, OpeningClaimEqualityPlan as Stage5OpeningClaimEqualityPlan, OpeningClaimPlan as Stage5OpeningClaimPlan, OpeningInputPlan as Stage5OpeningInputPlan, + OpeningEqualityMode as Stage5OpeningEqualityMode, PointConcatPlan as Stage5PointConcatPlan, PointSlicePlan as Stage5PointSlicePlan, + ProgramStepKind as Stage5ProgramStepKind, ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params, StageProgramPlanNoPointZeros as Stage5CpuProgramPlan, SumcheckBatchPlan as Stage5SumcheckBatchPlan, @@ -27,6 +31,7 @@ pub use super::common::{ SumcheckEvalPlan as Stage5SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage5SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage5TranscriptAbsorbBytesPlan, + TranscriptSqueezeKind as Stage5TranscriptSqueezeKind, TranscriptSqueezePlan as Stage5TranscriptSqueezePlan, }; @@ -42,27 +47,22 @@ pub enum VerifyStage5Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage5RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); -pub const STAGE5_PARAMS: Stage5Params = Stage5Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE5_PARAMS: Stage5Params = Stage5Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE5_PROGRAM_STEPS: &[Stage5ProgramStepPlan] = &[ - Stage5ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage5.instruction_read_raf.gamma" }, - Stage5ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage5.ram_ra_claim_reduction.gamma" }, - Stage5ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage5.sumcheck" }, + Stage5ProgramStepPlan { kind: Stage5ProgramStepKind::TranscriptSqueeze, symbol: "stage5.instruction_read_raf.gamma" }, + Stage5ProgramStepPlan { kind: Stage5ProgramStepKind::TranscriptSqueeze, symbol: "stage5.ram_ra_claim_reduction.gamma" }, + Stage5ProgramStepPlan { kind: Stage5ProgramStepKind::SumcheckDriver, symbol: "stage5.sumcheck" }, ]; pub const STAGE5_TRANSCRIPT_SQUEEZES: &[Stage5TranscriptSqueezePlan] = &[ - Stage5TranscriptSqueezePlan { symbol: "stage5.instruction_read_raf.gamma", label: "instruction_read_raf_gamma", kind: "challenge_scalar", count: 1 }, - Stage5TranscriptSqueezePlan { symbol: "stage5.ram_ra_claim_reduction.gamma", label: "ram_ra_claim_reduction_gamma", kind: "challenge_scalar", count: 1 }, + Stage5TranscriptSqueezePlan { symbol: "stage5.instruction_read_raf.gamma", label: "instruction_read_raf_gamma", kind: Stage5TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage5TranscriptSqueezePlan { symbol: "stage5.ram_ra_claim_reduction.gamma", label: "ram_ra_claim_reduction_gamma", kind: Stage5TranscriptSqueezeKind::ChallengeScalar, count: 1 }, ]; pub const STAGE5_TRANSCRIPT_ABSORB_BYTES: &[Stage5TranscriptAbsorbBytesPlan] = &[ @@ -70,14 +70,14 @@ pub const STAGE5_TRANSCRIPT_ABSORB_BYTES: &[Stage5TranscriptAbsorbBytesPlan] = & ]; pub const STAGE5_OPENING_INPUTS: &[Stage5OpeningInputPlan] = &[ - Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.LookupOutput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage5OpeningInputPlan { symbol: "stage5.input.stage2.product_virtual.LookupOutput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.LeftLookupOperand", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.RightLookupOperand", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage5OpeningInputPlan { symbol: "stage5.input.stage2.ram_raf.RamRa", source_stage: "stage2", source_claim: "stage2.ram_raf.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual" }, - Stage5OpeningInputPlan { symbol: "stage5.input.stage2.ram_read_write.RamRa", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual" }, - Stage5OpeningInputPlan { symbol: "stage5.input.stage4.ram_val_check.RamRa", source_stage: "stage4", source_claim: "stage4.ram_val_check.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual" }, - Stage5OpeningInputPlan { symbol: "stage5.input.stage4.registers.RegistersVal", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RegistersVal", oracle: "RegistersVal", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual" }, + Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.LookupOutput", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual }, + Stage5OpeningInputPlan { symbol: "stage5.input.stage2.product_virtual.LookupOutput", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual }, + Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.LeftLookupOperand", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", oracle: "LeftLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual }, + Stage5OpeningInputPlan { symbol: "stage5.input.stage2.instruction.RightLookupOperand", source_stage: "stage2", source_claim: "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", oracle: "RightLookupOperand", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual }, + Stage5OpeningInputPlan { symbol: "stage5.input.stage2.ram_raf.RamRa", source_stage: "stage2", source_claim: "stage2.ram_raf.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual }, + Stage5OpeningInputPlan { symbol: "stage5.input.stage2.ram_read_write.RamRa", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual }, + Stage5OpeningInputPlan { symbol: "stage5.input.stage4.ram_val_check.RamRa", source_stage: "stage4", source_claim: "stage4.ram_val_check.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual }, + Stage5OpeningInputPlan { symbol: "stage5.input.stage4.registers.RegistersVal", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RegistersVal", oracle: "RegistersVal", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage5ClaimKind::Virtual }, ]; pub const STAGE5_FIELD_CONSTANTS: &[Stage5FieldConstantPlan] = &[ @@ -85,46 +85,40 @@ pub const STAGE5_FIELD_CONSTANTS: &[Stage5FieldConstantPlan] = &[ ]; pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[ - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.gamma2", kind: "op", formula: "field.pow:2", operands: "stage5.instruction_read_raf.gamma" }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.LeftLookupOperand", kind: "op", formula: "field.mul", operands: "stage5.instruction_read_raf.gamma|stage5.input.stage2.instruction.LeftLookupOperand" }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.RightLookupOperand", kind: "op", formula: "field.mul", operands: "stage5.instruction_read_raf.gamma2|stage5.input.stage2.instruction.RightLookupOperand" }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.partial.LookupOutputLeftOperand", kind: "op", formula: "field.add", operands: "stage5.input.stage2.instruction.LookupOutput|stage5.instruction_read_raf.term.LeftLookupOperand" }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.claim_expr", kind: "op", formula: "field.add", operands: "stage5.instruction_read_raf.partial.LookupOutputLeftOperand|stage5.instruction_read_raf.term.RightLookupOperand" }, - Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.gamma2", kind: "op", formula: "field.pow:2", operands: "stage5.ram_ra_claim_reduction.gamma" }, - Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaReadWrite", kind: "op", formula: "field.mul", operands: "stage5.ram_ra_claim_reduction.gamma|stage5.input.stage2.ram_read_write.RamRa" }, - Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaValCheck", kind: "op", formula: "field.mul", operands: "stage5.ram_ra_claim_reduction.gamma2|stage5.input.stage4.ram_val_check.RamRa" }, - Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.partial.RafReadWrite", kind: "op", formula: "field.add", operands: "stage5.input.stage2.ram_raf.RamRa|stage5.ram_ra_claim_reduction.term.RamRaReadWrite" }, - Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.claim_expr", kind: "op", formula: "field.add", operands: "stage5.ram_ra_claim_reduction.partial.RafReadWrite|stage5.ram_ra_claim_reduction.term.RamRaValCheck" }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.gamma2", kind: Stage5FieldExprKind::Pow(2), operands: "stage5.instruction_read_raf.gamma" }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.LeftLookupOperand", kind: Stage5FieldExprKind::Mul, operands: "stage5.instruction_read_raf.gamma|stage5.input.stage2.instruction.LeftLookupOperand" }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.RightLookupOperand", kind: Stage5FieldExprKind::Mul, operands: "stage5.instruction_read_raf.gamma2|stage5.input.stage2.instruction.RightLookupOperand" }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.partial.LookupOutputLeftOperand", kind: Stage5FieldExprKind::Add, operands: "stage5.input.stage2.instruction.LookupOutput|stage5.instruction_read_raf.term.LeftLookupOperand" }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.claim_expr", kind: Stage5FieldExprKind::Add, operands: "stage5.instruction_read_raf.partial.LookupOutputLeftOperand|stage5.instruction_read_raf.term.RightLookupOperand" }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.gamma2", kind: Stage5FieldExprKind::Pow(2), operands: "stage5.ram_ra_claim_reduction.gamma" }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaReadWrite", kind: Stage5FieldExprKind::Mul, operands: "stage5.ram_ra_claim_reduction.gamma|stage5.input.stage2.ram_read_write.RamRa" }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaValCheck", kind: Stage5FieldExprKind::Mul, operands: "stage5.ram_ra_claim_reduction.gamma2|stage5.input.stage4.ram_val_check.RamRa" }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.partial.RafReadWrite", kind: Stage5FieldExprKind::Add, operands: "stage5.input.stage2.ram_raf.RamRa|stage5.ram_ra_claim_reduction.term.RamRaReadWrite" }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.claim_expr", kind: Stage5FieldExprKind::Add, operands: "stage5.ram_ra_claim_reduction.partial.RafReadWrite|stage5.ram_ra_claim_reduction.term.RamRaValCheck" }, ]; pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[ ]; pub const STAGE5_SUMCHECK_CLAIMS: &[Stage5SumcheckClaimPlan] = &[ - Stage5SumcheckClaimPlan { symbol: "stage5.instruction_read_raf.input", stage: "stage5", domain: "jolt.stage5_instruction_read_raf_domain", num_rounds: 144, degree: 10, claim: "stage5.instruction_read_raf.weighted_lookup_values", kernel: None, relation: Some("jolt.stage5.instruction_read_raf"), claim_value: "stage5.instruction_read_raf.claim_expr", input_openings: "stage5.input.stage2.instruction.LookupOutput|stage5.input.stage2.instruction.LeftLookupOperand|stage5.input.stage2.instruction.RightLookupOperand" }, - Stage5SumcheckClaimPlan { symbol: "stage5.ram_ra_claim_reduction.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage5.ram_ra_claim_reduction.weighted_ram_ra", kernel: None, relation: Some("jolt.stage5.ram_ra_claim_reduction"), claim_value: "stage5.ram_ra_claim_reduction.claim_expr", input_openings: "stage5.input.stage2.ram_raf.RamRa|stage5.input.stage2.ram_read_write.RamRa|stage5.input.stage4.ram_val_check.RamRa" }, - Stage5SumcheckClaimPlan { symbol: "stage5.registers_val_evaluation.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage5.registers_val_evaluation.registers_val", kernel: None, relation: Some("jolt.stage5.registers_val_evaluation"), claim_value: "stage5.input.stage4.registers.RegistersVal", input_openings: "stage5.input.stage4.registers.RegistersVal" }, -]; -pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 128, - 16, + Stage5SumcheckClaimPlan { symbol: "stage5.instruction_read_raf.input", stage: "stage5", domain: "jolt.stage5_instruction_read_raf_domain", num_rounds: 144, degree: 10, claim: "stage5.instruction_read_raf.weighted_lookup_values", kernel: None, relation: Some(Stage5RelationKind::Stage5InstructionReadRaf), claim_value: "stage5.instruction_read_raf.claim_expr", input_openings: "stage5.input.stage2.instruction.LookupOutput|stage5.input.stage2.instruction.LeftLookupOperand|stage5.input.stage2.instruction.RightLookupOperand" }, + Stage5SumcheckClaimPlan { symbol: "stage5.ram_ra_claim_reduction.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage5.ram_ra_claim_reduction.weighted_ram_ra", kernel: None, relation: Some(Stage5RelationKind::Stage5RamRaClaimReduction), claim_value: "stage5.ram_ra_claim_reduction.claim_expr", input_openings: "stage5.input.stage2.ram_raf.RamRa|stage5.input.stage2.ram_read_write.RamRa|stage5.input.stage4.ram_val_check.RamRa" }, + Stage5SumcheckClaimPlan { symbol: "stage5.registers_val_evaluation.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage5.registers_val_evaluation.registers_val", kernel: None, relation: Some(Stage5RelationKind::Stage5RegistersValEvaluation), claim_value: "stage5.input.stage4.registers.RegistersVal", input_openings: "stage5.input.stage4.registers.RegistersVal" }, ]; +pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[128, 16]; pub const STAGE5_SUMCHECK_BATCHES: &[Stage5SumcheckBatchPlan] = &[ Stage5SumcheckBatchPlan { symbol: "stage5.batch", stage: "stage5", proof_slot: "stage5.sumcheck", policy: "jolt_core_stage5_aligned", count: 3, ordered_claims: "stage5.instruction_read_raf.input|stage5.ram_ra_claim_reduction.input|stage5.registers_val_evaluation.input", claim_operands: "stage5.instruction_read_raf.input|stage5.ram_ra_claim_reduction.input|stage5.registers_val_evaluation.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; -pub const STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 128, - 16, -]; +pub const STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[128, 16]; pub const STAGE5_SUMCHECK_DRIVERS: &[Stage5SumcheckDriverPlan] = &[ - Stage5SumcheckDriverPlan { symbol: "stage5.sumcheck", stage: "stage5", proof_slot: "stage5.sumcheck", kernel: None, relation: Some("jolt.stage5.batched"), batch: "stage5.batch", policy: "jolt_core_stage5_aligned", round_schedule: STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 144, degree: 10 }, + Stage5SumcheckDriverPlan { symbol: "stage5.sumcheck", stage: "stage5", proof_slot: "stage5.sumcheck", kernel: None, relation: Some(Stage5RelationKind::Stage5Batched), batch: "stage5.batch", policy: "jolt_core_stage5_aligned", round_schedule: STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 144, degree: 10 }, ]; pub const STAGE5_SUMCHECK_INSTANCE_RESULTS: &[Stage5SumcheckInstanceResultPlan] = &[ - Stage5SumcheckInstanceResultPlan { symbol: "stage5.instruction_read_raf.instance", source: "stage5.sumcheck", claim: "stage5.instruction_read_raf.input", relation: "jolt.stage5.instruction_read_raf", index: 0, point_arity: 144, num_rounds: 144, round_offset: 0, point_order: "instruction_read_raf", degree: 10 }, - Stage5SumcheckInstanceResultPlan { symbol: "stage5.ram_ra_claim_reduction.instance", source: "stage5.sumcheck", claim: "stage5.ram_ra_claim_reduction.input", relation: "jolt.stage5.ram_ra_claim_reduction", index: 1, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: "reverse", degree: 2 }, - Stage5SumcheckInstanceResultPlan { symbol: "stage5.registers_val_evaluation.instance", source: "stage5.sumcheck", claim: "stage5.registers_val_evaluation.input", relation: "jolt.stage5.registers_val_evaluation", index: 2, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: "reverse", degree: 3 }, + Stage5SumcheckInstanceResultPlan { symbol: "stage5.instruction_read_raf.instance", source: "stage5.sumcheck", claim: "stage5.instruction_read_raf.input", relation: Stage5RelationKind::Stage5InstructionReadRaf, index: 0, point_arity: 144, num_rounds: 144, round_offset: 0, point_order: "instruction_read_raf", degree: 10 }, + Stage5SumcheckInstanceResultPlan { symbol: "stage5.ram_ra_claim_reduction.instance", source: "stage5.sumcheck", claim: "stage5.ram_ra_claim_reduction.input", relation: Stage5RelationKind::Stage5RamRaClaimReduction, index: 1, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: "reverse", degree: 2 }, + Stage5SumcheckInstanceResultPlan { symbol: "stage5.registers_val_evaluation.instance", source: "stage5.sumcheck", claim: "stage5.registers_val_evaluation.input", relation: Stage5RelationKind::Stage5RegistersValEvaluation, index: 2, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: "reverse", degree: 3 }, ]; pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[ @@ -210,63 +204,63 @@ pub const STAGE5_POINT_CONCATS: &[Stage5PointConcatPlan] = &[ Stage5PointConcatPlan { symbol: "stage5.registers_val_evaluation.point.RdWa", layout: "register_address_then_cycle", arity: 23, inputs: "stage5.registers_val_evaluation.point.RegisterAddress|stage5.registers_val_evaluation.instance" }, ]; pub const STAGE5_OPENING_CLAIMS: &[Stage5OpeningClaimPlan] = &[ - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_0", oracle: "LookupTableFlag_0", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_0" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_1", oracle: "LookupTableFlag_1", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_1" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_2", oracle: "LookupTableFlag_2", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_2" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_3", oracle: "LookupTableFlag_3", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_3" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_4", oracle: "LookupTableFlag_4", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_4" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_5", oracle: "LookupTableFlag_5", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_5" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_6", oracle: "LookupTableFlag_6", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_6" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_7", oracle: "LookupTableFlag_7", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_7" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_8", oracle: "LookupTableFlag_8", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_8" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_9", oracle: "LookupTableFlag_9", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_9" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_10", oracle: "LookupTableFlag_10", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_10" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_11", oracle: "LookupTableFlag_11", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_11" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_12", oracle: "LookupTableFlag_12", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_12" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_13", oracle: "LookupTableFlag_13", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_13" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_14", oracle: "LookupTableFlag_14", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_14" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_15", oracle: "LookupTableFlag_15", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_15" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_16", oracle: "LookupTableFlag_16", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_16" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_17", oracle: "LookupTableFlag_17", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_17" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_18", oracle: "LookupTableFlag_18", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_18" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_19", oracle: "LookupTableFlag_19", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_19" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_20", oracle: "LookupTableFlag_20", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_20" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_21", oracle: "LookupTableFlag_21", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_21" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_22", oracle: "LookupTableFlag_22", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_22" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_23", oracle: "LookupTableFlag_23", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_23" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_24", oracle: "LookupTableFlag_24", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_24" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_25", oracle: "LookupTableFlag_25", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_25" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_26", oracle: "LookupTableFlag_26", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_26" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_27", oracle: "LookupTableFlag_27", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_27" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_28", oracle: "LookupTableFlag_28", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_28" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_29", oracle: "LookupTableFlag_29", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_29" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_30", oracle: "LookupTableFlag_30", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_30" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_31", oracle: "LookupTableFlag_31", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_31" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_32", oracle: "LookupTableFlag_32", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_32" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_33", oracle: "LookupTableFlag_33", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_33" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_34", oracle: "LookupTableFlag_34", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_34" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_35", oracle: "LookupTableFlag_35", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_35" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_36", oracle: "LookupTableFlag_36", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_36" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_37", oracle: "LookupTableFlag_37", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_37" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_38", oracle: "LookupTableFlag_38", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_38" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_39", oracle: "LookupTableFlag_39", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_39" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_40", oracle: "LookupTableFlag_40", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_40" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_0", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_0" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_1", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_1" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_2", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_2" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_3", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_3" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_4", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_4" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_5", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_5" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_6", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_6" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.InstructionRa_7", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_7" }, - Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRafFlag", oracle: "InstructionRafFlag", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.InstructionRafFlag" }, - Stage5OpeningClaimPlan { symbol: "stage5.ram_ra_claim_reduction.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual", point_source: "stage5.ram_ra_claim_reduction.point.RamRa", eval_source: "stage5.ram_ra_claim_reduction.eval.RamRa" }, - Stage5OpeningClaimPlan { symbol: "stage5.registers_val_evaluation.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage5.registers_val_evaluation.instance", eval_source: "stage5.registers_val_evaluation.eval.RdInc" }, - Stage5OpeningClaimPlan { symbol: "stage5.registers_val_evaluation.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual", point_source: "stage5.registers_val_evaluation.point.RdWa", eval_source: "stage5.registers_val_evaluation.eval.RdWa" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_0", oracle: "LookupTableFlag_0", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_0" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_1", oracle: "LookupTableFlag_1", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_1" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_2", oracle: "LookupTableFlag_2", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_2" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_3", oracle: "LookupTableFlag_3", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_3" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_4", oracle: "LookupTableFlag_4", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_4" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_5", oracle: "LookupTableFlag_5", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_5" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_6", oracle: "LookupTableFlag_6", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_6" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_7", oracle: "LookupTableFlag_7", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_7" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_8", oracle: "LookupTableFlag_8", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_8" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_9", oracle: "LookupTableFlag_9", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_9" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_10", oracle: "LookupTableFlag_10", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_10" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_11", oracle: "LookupTableFlag_11", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_11" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_12", oracle: "LookupTableFlag_12", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_12" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_13", oracle: "LookupTableFlag_13", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_13" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_14", oracle: "LookupTableFlag_14", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_14" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_15", oracle: "LookupTableFlag_15", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_15" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_16", oracle: "LookupTableFlag_16", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_16" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_17", oracle: "LookupTableFlag_17", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_17" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_18", oracle: "LookupTableFlag_18", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_18" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_19", oracle: "LookupTableFlag_19", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_19" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_20", oracle: "LookupTableFlag_20", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_20" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_21", oracle: "LookupTableFlag_21", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_21" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_22", oracle: "LookupTableFlag_22", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_22" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_23", oracle: "LookupTableFlag_23", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_23" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_24", oracle: "LookupTableFlag_24", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_24" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_25", oracle: "LookupTableFlag_25", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_25" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_26", oracle: "LookupTableFlag_26", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_26" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_27", oracle: "LookupTableFlag_27", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_27" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_28", oracle: "LookupTableFlag_28", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_28" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_29", oracle: "LookupTableFlag_29", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_29" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_30", oracle: "LookupTableFlag_30", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_30" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_31", oracle: "LookupTableFlag_31", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_31" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_32", oracle: "LookupTableFlag_32", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_32" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_33", oracle: "LookupTableFlag_33", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_33" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_34", oracle: "LookupTableFlag_34", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_34" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_35", oracle: "LookupTableFlag_35", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_35" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_36", oracle: "LookupTableFlag_36", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_36" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_37", oracle: "LookupTableFlag_37", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_37" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_38", oracle: "LookupTableFlag_38", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_38" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_39", oracle: "LookupTableFlag_39", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_39" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_40", oracle: "LookupTableFlag_40", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_40" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_0", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_0" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_1", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_1" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_2", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_2" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_3", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_3" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_4", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_4" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_5", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_5" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_6", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_6" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.InstructionRa_7", eval_source: "stage5.instruction_read_raf.eval.InstructionRa_7" }, + Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.InstructionRafFlag", oracle: "InstructionRafFlag", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.InstructionRafFlag" }, + Stage5OpeningClaimPlan { symbol: "stage5.ram_ra_claim_reduction.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.ram_ra_claim_reduction.point.RamRa", eval_source: "stage5.ram_ra_claim_reduction.eval.RamRa" }, + Stage5OpeningClaimPlan { symbol: "stage5.registers_val_evaluation.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Committed, point_source: "stage5.registers_val_evaluation.instance", eval_source: "stage5.registers_val_evaluation.eval.RdInc" }, + Stage5OpeningClaimPlan { symbol: "stage5.registers_val_evaluation.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.registers_val_evaluation.point.RdWa", eval_source: "stage5.registers_val_evaluation.eval.RdWa" }, ]; pub const STAGE5_OPENING_EQUALITIES: &[Stage5OpeningClaimEqualityPlan] = &[ - Stage5OpeningClaimEqualityPlan { symbol: "stage5.instruction.lookup_output_claim_consistency", mode: "point_and_eval", lhs: "stage5.input.stage2.instruction.LookupOutput", rhs: "stage5.input.stage2.product_virtual.LookupOutput" }, + Stage5OpeningClaimEqualityPlan { symbol: "stage5.instruction.lookup_output_claim_consistency", mode: Stage5OpeningEqualityMode::PointAndEval, lhs: "stage5.input.stage2.instruction.LookupOutput", rhs: "stage5.input.stage2.product_virtual.LookupOutput" }, ]; pub const STAGE5_OPENING_BATCHES: &[Stage5OpeningBatchPlan] = &[ @@ -326,14 +320,14 @@ where let mut artifacts = Stage5ExecutionArtifacts::default(); for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage5ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage5Error::MissingValue { symbol: step.symbol, })?; verify_stage5_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "transcript_absorb_bytes" => { + Stage5ProgramStepKind::TranscriptAbsorbBytes => { let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or( VerifyStage5Error::MissingValue { symbol: step.symbol, @@ -341,19 +335,13 @@ where )?; absorb_stage5_bytes(absorb, transcript); } - "sumcheck_driver" => { + Stage5ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage5Error::MissingProof { driver: step.symbol, })?; verify_stage5_driver(program, driver, proof, &mut store, transcript, &mut artifacts)?; } - _ => { - return Err(VerifyStage5Error::InvalidProof { - driver: step.symbol, - reason: "unsupported stage5 program step", - }); - } } } artifacts @@ -422,12 +410,17 @@ where .ok_or(VerifyStage5Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage5Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage5.batched" => { + Stage5RelationKind::Stage5Batched => { verify_batched_stage5(program, driver, proof, store, transcript)? } - _ => return Err(VerifyStage5Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); Ok(()) @@ -540,18 +533,23 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let relation = claim.relation.unwrap_or(""); + let Some(relation) = claim.relation else { + return Err(VerifyStage5Error::InvalidProof { + driver: driver.symbol, + reason: "missing claim relation", + }); + }; let value = match relation { - "jolt.stage5.instruction_read_raf" => { + Stage5RelationKind::Stage5InstructionReadRaf => { expected_instruction_read_raf(store, evals, local_point)? } - "jolt.stage5.ram_ra_claim_reduction" => { + Stage5RelationKind::Stage5RamRaClaimReduction => { expected_ram_ra_claim_reduction(store, evals, local_point)? } - "jolt.stage5.registers_val_evaluation" => { + Stage5RelationKind::Stage5RegistersValEvaluation => { expected_registers_val_evaluation(store, evals, local_point)? } - _ => return Err(VerifyStage5Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; } diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index df9438b3fe..6166602649 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -13,18 +13,23 @@ pub type Stage6Proof = super::common::StageProof; pub type Stage6OpeningInputValue = super::common::StageOpeningInputValue; pub use super::common::{ - FieldConstantPlan as Stage6FieldConstantPlan, FieldExprPlan as Stage6FieldExprPlan, + ClaimKind as Stage6ClaimKind, RelationKind as Stage6RelationKind, FieldConstantPlan as Stage6FieldConstantPlan, + FieldExprKind as Stage6FieldExprKind, + FieldExprPlan as Stage6FieldExprPlan, KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan, OpeningClaimEqualityPlan as Stage6OpeningClaimEqualityPlan, OpeningClaimPlan as Stage6OpeningClaimPlan, OpeningInputPlan as Stage6OpeningInputPlan, + OpeningEqualityMode as Stage6OpeningEqualityMode, PointConcatPlan as Stage6PointConcatPlan, PointSlicePlan as Stage6PointSlicePlan, - PointZeroPlan as Stage6PointZeroPlan, ProgramStepPlan as Stage6ProgramStepPlan, + PointZeroPlan as Stage6PointZeroPlan, ProgramStepKind as Stage6ProgramStepKind, + ProgramStepPlan as Stage6ProgramStepPlan, StageParams as Stage6Params, StageProgramPlan as Stage6CpuProgramPlan, SumcheckBatchPlan as Stage6SumcheckBatchPlan, SumcheckClaimPlan as Stage6SumcheckClaimPlan, SumcheckDriverPlan as Stage6SumcheckDriverPlan, SumcheckEvalPlan as Stage6SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage6SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage6TranscriptAbsorbBytesPlan, + TranscriptSqueezeKind as Stage6TranscriptSqueezeKind, TranscriptSqueezePlan as Stage6TranscriptSqueezePlan, }; @@ -80,7 +85,6 @@ pub struct Stage6VerifierData { } const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { - hamming_booleanity_relation: "jolt.stage6.hamming_booleanity", hamming_booleanity_instance: "stage6.hamming_booleanity.instance", booleanity_point: "stage6.booleanity.point", stage5_instruction_ra0: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", @@ -143,41 +147,36 @@ pub enum VerifyStage6Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage6RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); -pub const STAGE6_PARAMS: Stage6Params = Stage6Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE6_PARAMS: Stage6Params = Stage6Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE6_PROGRAM_STEPS: &[Stage6ProgramStepPlan] = &[ - Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.gamma" }, - Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage1_gamma" }, - Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage2_gamma" }, - Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage3_gamma" }, - Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage4_gamma" }, - Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.bytecode_read_raf.stage5_gamma" }, - Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.booleanity.gamma" }, - Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.instruction_ra_virtual.gamma" }, - Stage6ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage6.inc_claim_reduction.gamma" }, - Stage6ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage6.sumcheck" }, + Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.gamma" }, + Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.stage1_gamma" }, + Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.stage2_gamma" }, + Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.stage3_gamma" }, + Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.stage4_gamma" }, + Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.bytecode_read_raf.stage5_gamma" }, + Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.booleanity.gamma" }, + Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.instruction_ra_virtual.gamma" }, + Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::TranscriptSqueeze, symbol: "stage6.inc_claim_reduction.gamma" }, + Stage6ProgramStepPlan { kind: Stage6ProgramStepKind::SumcheckDriver, symbol: "stage6.sumcheck" }, ]; pub const STAGE6_TRANSCRIPT_SQUEEZES: &[Stage6TranscriptSqueezePlan] = &[ - Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.gamma", label: "bc_raf_gamma", kind: "challenge_scalar", count: 1 }, - Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage1_gamma", label: "bc_raf_stage1_gamma", kind: "challenge_scalar", count: 1 }, - Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage2_gamma", label: "bc_raf_stage2_gamma", kind: "challenge_scalar", count: 1 }, - Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage3_gamma", label: "bc_raf_stage3_gamma", kind: "challenge_scalar", count: 1 }, - Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage4_gamma", label: "bc_raf_stage4_gamma", kind: "challenge_scalar", count: 1 }, - Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage5_gamma", label: "bc_raf_stage5_gamma", kind: "challenge_scalar", count: 1 }, - Stage6TranscriptSqueezePlan { symbol: "stage6.booleanity.gamma", label: "booleanity_gamma", kind: "challenge_scalar", count: 1 }, - Stage6TranscriptSqueezePlan { symbol: "stage6.instruction_ra_virtual.gamma", label: "inst_ra_virtual_gamma", kind: "challenge_scalar", count: 1 }, - Stage6TranscriptSqueezePlan { symbol: "stage6.inc_claim_reduction.gamma", label: "inc_reduction_gamma", kind: "challenge_scalar", count: 1 }, + Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.gamma", label: "bc_raf_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage1_gamma", label: "bc_raf_stage1_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage2_gamma", label: "bc_raf_stage2_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage3_gamma", label: "bc_raf_stage3_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage4_gamma", label: "bc_raf_stage4_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage6TranscriptSqueezePlan { symbol: "stage6.bytecode_read_raf.stage5_gamma", label: "bc_raf_stage5_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage6TranscriptSqueezePlan { symbol: "stage6.booleanity.gamma", label: "booleanity_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage6TranscriptSqueezePlan { symbol: "stage6.instruction_ra_virtual.gamma", label: "inst_ra_virtual_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 }, + Stage6TranscriptSqueezePlan { symbol: "stage6.inc_claim_reduction.gamma", label: "inc_reduction_gamma", kind: Stage6TranscriptSqueezeKind::ChallengeScalar, count: 1 }, ]; pub const STAGE6_TRANSCRIPT_ABSORB_BYTES: &[Stage6TranscriptAbsorbBytesPlan] = &[ @@ -185,97 +184,97 @@ pub const STAGE6_TRANSCRIPT_ABSORB_BYTES: &[Stage6TranscriptAbsorbBytesPlan] = & ]; pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[ - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.UnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.Imm", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAddOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAddOperands", oracle: "OpFlagAddOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagSubtractOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagSubtractOperands", oracle: "OpFlagSubtractOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagMultiplyOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagMultiplyOperands", oracle: "OpFlagMultiplyOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagLoad", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagLoad", oracle: "OpFlagLoad", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagStore", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagStore", oracle: "OpFlagStore", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagJump", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagWriteLookupOutputToRD", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagVirtualInstruction", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAssert", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAssert", oracle: "OpFlagAssert", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", oracle: "OpFlagDoNotUpdateUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAdvice", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAdvice", oracle: "OpFlagAdvice", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsCompressed", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsCompressed", oracle: "OpFlagIsCompressed", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsFirstInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsLastInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsLastInSequence", oracle: "OpFlagIsLastInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagJump", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage2.InstructionFlagBranch", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.InstructionFlagBranch", oracle: "InstructionFlagBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagWriteLookupOutputToRD", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagVirtualInstruction", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.Imm", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.UnexpandedPC", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", oracle: "InstructionFlagLeftOperandIsRs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", oracle: "InstructionFlagLeftOperandIsPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", oracle: "InstructionFlagRightOperandIsRs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", oracle: "InstructionFlagRightOperandIsImm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.InstructionFlagIsNoop", oracle: "InstructionFlagIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage4.RdWa", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage4.Rs1Ra", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.Rs1Ra", oracle: "Rs1Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage4.Rs2Ra", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.Rs2Ra", oracle: "Rs2Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.registers_val_evaluation.RdWa", source_stage: "stage5", source_claim: "stage5.registers_val_evaluation.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.InstructionRafFlag", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRafFlag", oracle: "InstructionRafFlag", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_0", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_0", oracle: "LookupTableFlag_0", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_1", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_1", oracle: "LookupTableFlag_1", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_2", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_2", oracle: "LookupTableFlag_2", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_3", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_3", oracle: "LookupTableFlag_3", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_4", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_4", oracle: "LookupTableFlag_4", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_5", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_5", oracle: "LookupTableFlag_5", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_6", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_6", oracle: "LookupTableFlag_6", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_7", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_7", oracle: "LookupTableFlag_7", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_8", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_8", oracle: "LookupTableFlag_8", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_9", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_9", oracle: "LookupTableFlag_9", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_10", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_10", oracle: "LookupTableFlag_10", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_11", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_11", oracle: "LookupTableFlag_11", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_12", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_12", oracle: "LookupTableFlag_12", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_13", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_13", oracle: "LookupTableFlag_13", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_14", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_14", oracle: "LookupTableFlag_14", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_15", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_15", oracle: "LookupTableFlag_15", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_16", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_16", oracle: "LookupTableFlag_16", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_17", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_17", oracle: "LookupTableFlag_17", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_18", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_18", oracle: "LookupTableFlag_18", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_19", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_19", oracle: "LookupTableFlag_19", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_20", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_20", oracle: "LookupTableFlag_20", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_21", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_21", oracle: "LookupTableFlag_21", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_22", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_22", oracle: "LookupTableFlag_22", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_23", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_23", oracle: "LookupTableFlag_23", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_24", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_24", oracle: "LookupTableFlag_24", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_25", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_25", oracle: "LookupTableFlag_25", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_26", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_26", oracle: "LookupTableFlag_26", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_27", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_27", oracle: "LookupTableFlag_27", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_28", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_28", oracle: "LookupTableFlag_28", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_29", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_29", oracle: "LookupTableFlag_29", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_30", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_30", oracle: "LookupTableFlag_30", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_31", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_31", oracle: "LookupTableFlag_31", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_32", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_32", oracle: "LookupTableFlag_32", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_33", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_33", oracle: "LookupTableFlag_33", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_34", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_34", oracle: "LookupTableFlag_34", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_35", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_35", oracle: "LookupTableFlag_35", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_36", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_36", oracle: "LookupTableFlag_36", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_37", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_37", oracle: "LookupTableFlag_37", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_38", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_38", oracle: "LookupTableFlag_38", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_39", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_39", oracle: "LookupTableFlag_39", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_40", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_40", oracle: "LookupTableFlag_40", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.PC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.PC", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", source_stage: "stage5", source_claim: "stage5.ram_ra_claim_reduction.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage1.LookupOutput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage2.ram_read_write.RamInc", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage4.ram_val_check.RamInc", source_stage: "stage4", source_claim: "stage4.ram_val_check.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage4.registers_read_write.RdInc", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed" }, - Stage6OpeningInputPlan { symbol: "stage6.input.stage5.registers_val_evaluation.RdInc", source_stage: "stage5", source_claim: "stage5.registers_val_evaluation.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed" }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.UnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.Imm", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAddOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAddOperands", oracle: "OpFlagAddOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagSubtractOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagSubtractOperands", oracle: "OpFlagSubtractOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagMultiplyOperands", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagMultiplyOperands", oracle: "OpFlagMultiplyOperands", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagLoad", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagLoad", oracle: "OpFlagLoad", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagStore", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagStore", oracle: "OpFlagStore", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagJump", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagWriteLookupOutputToRD", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagVirtualInstruction", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAssert", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAssert", oracle: "OpFlagAssert", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", oracle: "OpFlagDoNotUpdateUnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagAdvice", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagAdvice", oracle: "OpFlagAdvice", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsCompressed", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsCompressed", oracle: "OpFlagIsCompressed", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsFirstInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.OpFlagIsLastInSequence", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.OpFlagIsLastInSequence", oracle: "OpFlagIsLastInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagJump", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagJump", oracle: "OpFlagJump", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage2.InstructionFlagBranch", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.InstructionFlagBranch", oracle: "InstructionFlagBranch", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagWriteLookupOutputToRD", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", oracle: "OpFlagWriteLookupOutputToRD", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage2.OpFlagVirtualInstruction", source_stage: "stage2", source_claim: "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.Imm", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.Imm", oracle: "Imm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.UnexpandedPC", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", oracle: "InstructionFlagLeftOperandIsRs1Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", oracle: "InstructionFlagLeftOperandIsPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", oracle: "InstructionFlagRightOperandIsRs2Value", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm", source_stage: "stage3", source_claim: "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", oracle: "InstructionFlagRightOperandIsImm", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.InstructionFlagIsNoop", oracle: "InstructionFlagIsNoop", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.OpFlagVirtualInstruction", oracle: "OpFlagVirtualInstruction", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", oracle: "OpFlagIsFirstInSequence", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage4.RdWa", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage4.Rs1Ra", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.Rs1Ra", oracle: "Rs1Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage4.Rs2Ra", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.Rs2Ra", oracle: "Rs2Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.registers_val_evaluation.RdWa", source_stage: "stage5", source_claim: "stage5.registers_val_evaluation.opening.RdWa", oracle: "RdWa", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.InstructionRafFlag", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRafFlag", oracle: "InstructionRafFlag", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_0", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_0", oracle: "LookupTableFlag_0", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_1", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_1", oracle: "LookupTableFlag_1", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_2", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_2", oracle: "LookupTableFlag_2", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_3", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_3", oracle: "LookupTableFlag_3", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_4", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_4", oracle: "LookupTableFlag_4", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_5", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_5", oracle: "LookupTableFlag_5", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_6", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_6", oracle: "LookupTableFlag_6", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_7", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_7", oracle: "LookupTableFlag_7", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_8", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_8", oracle: "LookupTableFlag_8", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_9", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_9", oracle: "LookupTableFlag_9", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_10", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_10", oracle: "LookupTableFlag_10", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_11", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_11", oracle: "LookupTableFlag_11", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_12", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_12", oracle: "LookupTableFlag_12", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_13", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_13", oracle: "LookupTableFlag_13", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_14", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_14", oracle: "LookupTableFlag_14", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_15", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_15", oracle: "LookupTableFlag_15", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_16", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_16", oracle: "LookupTableFlag_16", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_17", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_17", oracle: "LookupTableFlag_17", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_18", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_18", oracle: "LookupTableFlag_18", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_19", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_19", oracle: "LookupTableFlag_19", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_20", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_20", oracle: "LookupTableFlag_20", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_21", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_21", oracle: "LookupTableFlag_21", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_22", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_22", oracle: "LookupTableFlag_22", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_23", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_23", oracle: "LookupTableFlag_23", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_24", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_24", oracle: "LookupTableFlag_24", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_25", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_25", oracle: "LookupTableFlag_25", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_26", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_26", oracle: "LookupTableFlag_26", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_27", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_27", oracle: "LookupTableFlag_27", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_28", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_28", oracle: "LookupTableFlag_28", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_29", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_29", oracle: "LookupTableFlag_29", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_30", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_30", oracle: "LookupTableFlag_30", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_31", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_31", oracle: "LookupTableFlag_31", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_32", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_32", oracle: "LookupTableFlag_32", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_33", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_33", oracle: "LookupTableFlag_33", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_34", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_34", oracle: "LookupTableFlag_34", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_35", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_35", oracle: "LookupTableFlag_35", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_36", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_36", oracle: "LookupTableFlag_36", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_37", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_37", oracle: "LookupTableFlag_37", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_38", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_38", oracle: "LookupTableFlag_38", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_39", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_39", oracle: "LookupTableFlag_39", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.LookupTableFlag_40", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.LookupTableFlag_40", oracle: "LookupTableFlag_40", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.PC", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage3.spartan_shift.PC", source_stage: "stage3", source_claim: "stage3.spartan_shift.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", source_stage: "stage5", source_claim: "stage5.ram_ra_claim_reduction.opening.RamRa", oracle: "RamRa", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", source_stage: "stage5", source_claim: "stage5.instruction_read_raf.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.stage5_instruction_ra_chunk_domain", point_arity: 32, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage1.LookupOutput", source_stage: "stage1", source_claim: "stage1.outer_remaining.opening.LookupOutput", oracle: "LookupOutput", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage2.ram_read_write.RamInc", source_stage: "stage2", source_claim: "stage2.ram_read_write.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage4.ram_val_check.RamInc", source_stage: "stage4", source_claim: "stage4.ram_val_check.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage4.registers_read_write.RdInc", source_stage: "stage4", source_claim: "stage4.registers_read_write.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed }, + Stage6OpeningInputPlan { symbol: "stage6.input.stage5.registers_val_evaluation.RdInc", source_stage: "stage5", source_claim: "stage5.registers_val_evaluation.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed }, ]; pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ @@ -283,105 +282,99 @@ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ ]; macro_rules! stage6_field_expr { - ($symbol:literal, $formula:literal, $operands:literal) => { - Stage6FieldExprPlan { symbol: $symbol, kind: "op", formula: $formula, operands: $operands } + ($symbol:literal, $kind:expr, $operands:literal) => { + Stage6FieldExprPlan { symbol: $symbol, kind: $kind, operands: $operands } }; } #[rustfmt::skip] pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ - stage6_field_expr!("stage6.booleanity.gamma_sq_0", "field.pow:0", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_1", "field.pow:2", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_2", "field.pow:4", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_3", "field.pow:6", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_4", "field.pow:8", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_5", "field.pow:10", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_6", "field.pow:12", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_7", "field.pow:14", "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_sq_8", "field.pow:16", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_9", "field.pow:18", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_10", "field.pow:20", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_11", "field.pow:22", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_12", "field.pow:24", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_13", "field.pow:26", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_14", "field.pow:28", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_15", "field.pow:30", "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_sq_16", "field.pow:32", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_17", "field.pow:34", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_18", "field.pow:36", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_19", "field.pow:38", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_20", "field.pow:40", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_21", "field.pow:42", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_22", "field.pow:44", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_23", "field.pow:46", "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_sq_24", "field.pow:48", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_25", "field.pow:50", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_26", "field.pow:52", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_27", "field.pow:54", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_28", "field.pow:56", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_29", "field.pow:58", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_30", "field.pow:60", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_31", "field.pow:62", "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_sq_32", "field.pow:64", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_33", "field.pow:66", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_34", "field.pow:68", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_35", "field.pow:70", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_36", "field.pow:72", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_37", "field.pow:74", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_38", "field.pow:76", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_0", "field.pow:0", "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_pow_1", "field.pow:1", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_2", "field.pow:2", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_3", "field.pow:3", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_4", "field.pow:4", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_5", "field.pow:5", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_6", "field.pow:6", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_7", "field.pow:7", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_8", "field.pow:8", "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_pow_9", "field.pow:9", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_10", "field.pow:10", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_11", "field.pow:11", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_12", "field.pow:12", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_13", "field.pow:13", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_14", "field.pow:14", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_15", "field.pow:15", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_16", "field.pow:16", "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_pow_17", "field.pow:17", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_18", "field.pow:18", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_19", "field.pow:19", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_20", "field.pow:20", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_21", "field.pow:21", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_22", "field.pow:22", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_23", "field.pow:23", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_24", "field.pow:24", "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_pow_25", "field.pow:25", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_26", "field.pow:26", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_27", "field.pow:27", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_28", "field.pow:28", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_29", "field.pow:29", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_30", "field.pow:30", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_31", "field.pow:31", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_32", "field.pow:32", "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_pow_33", "field.pow:33", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_34", "field.pow:34", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_35", "field.pow:35", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_36", "field.pow:36", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_37", "field.pow:37", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_38", "field.pow:38", "stage6.booleanity.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term1.stage_gamma_pow|stage6.input.stage1.Imm"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term2.stage_gamma_pow|stage6.input.stage1.OpFlagAddOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term3.stage_gamma_pow|stage6.input.stage1.OpFlagSubtractOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term4.stage_gamma_pow|stage6.input.stage1.OpFlagMultiplyOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", "field.pow:5", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term5.stage_gamma_pow|stage6.input.stage1.OpFlagLoad"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", "field.pow:6", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term6.stage_gamma_pow|stage6.input.stage1.OpFlagStore"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", "field.pow:7", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term7.stage_gamma_pow|stage6.input.stage1.OpFlagJump"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", "field.pow:8", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term8.stage_gamma_pow|stage6.input.stage1.OpFlagWriteLookupOutputToRD"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", "field.pow:9", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term9.stage_gamma_pow|stage6.input.stage1.OpFlagVirtualInstruction"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", "field.pow:10", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term10.stage_gamma_pow|stage6.input.stage1.OpFlagAssert"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", "field.pow:11", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term11.stage_gamma_pow|stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", "field.pow:12", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term12.stage_gamma_pow|stage6.input.stage1.OpFlagAdvice"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", "field.pow:13", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term13.stage_gamma_pow|stage6.input.stage1.OpFlagIsCompressed"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", "field.pow:14", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term14.stage_gamma_pow|stage6.input.stage1.OpFlagIsFirstInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", "field.pow:15", "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term15.stage_gamma_pow|stage6.input.stage1.OpFlagIsLastInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term16.gamma_pow|stage6.input.stage2.OpFlagJump"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term17.stage_gamma_pow|stage6.input.stage2.InstructionFlagBranch"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term17.gamma_pow|stage6.bytecode_read_raf.claim.term17.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term18.stage_gamma_pow|stage6.input.stage2.OpFlagWriteLookupOutputToRD"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term18.gamma_pow|stage6.bytecode_read_raf.claim.term18.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term19.stage_gamma_pow|stage6.input.stage2.OpFlagVirtualInstruction"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term19.gamma_pow|stage6.bytecode_read_raf.claim.term19.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term20.gamma_pow|stage6.input.stage3.instruction_input.Imm"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term21.stage_gamma_pow|stage6.input.stage3.spartan_shift.UnexpandedPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term21.gamma_pow|stage6.bytecode_read_raf.claim.term21.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term22.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term22.gamma_pow|stage6.bytecode_read_raf.claim.term22.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term23.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term23.gamma_pow|stage6.bytecode_read_raf.claim.term23.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term24.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term24.gamma_pow|stage6.bytecode_read_raf.claim.term24.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", "field.pow:5", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term25.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term25.gamma_pow|stage6.bytecode_read_raf.claim.term25.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", "field.pow:6", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term26.stage_gamma_pow|stage6.input.stage3.spartan_shift.InstructionFlagIsNoop"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term26.gamma_pow|stage6.bytecode_read_raf.claim.term26.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", "field.pow:7", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term27.stage_gamma_pow|stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term27.gamma_pow|stage6.bytecode_read_raf.claim.term27.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", "field.pow:8", "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term28.stage_gamma_pow|stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term28.gamma_pow|stage6.bytecode_read_raf.claim.term28.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term29.gamma_pow|stage6.input.stage4.RdWa"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.stage4_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term30.stage_gamma_pow|stage6.input.stage4.Rs1Ra"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term30.gamma_pow|stage6.bytecode_read_raf.claim.term30.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.stage4_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term31.stage_gamma_pow|stage6.input.stage4.Rs2Ra"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term31.gamma_pow|stage6.bytecode_read_raf.claim.term31.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term32.gamma_pow|stage6.input.stage5.registers_val_evaluation.RdWa"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", "field.pow:1", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term33.stage_gamma_pow|stage6.input.stage5.InstructionRafFlag"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term33.gamma_pow|stage6.bytecode_read_raf.claim.term33.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", "field.pow:2", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term34.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_0"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term34.gamma_pow|stage6.bytecode_read_raf.claim.term34.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", "field.pow:3", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term35.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_1"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term35.gamma_pow|stage6.bytecode_read_raf.claim.term35.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term36.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_2"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term36.gamma_pow|stage6.bytecode_read_raf.claim.term36.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", "field.pow:5", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term37.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_3"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term37.gamma_pow|stage6.bytecode_read_raf.claim.term37.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", "field.pow:6", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term38.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_4"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term38.gamma_pow|stage6.bytecode_read_raf.claim.term38.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", "field.pow:7", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term39.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_5"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term39.gamma_pow|stage6.bytecode_read_raf.claim.term39.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", "field.pow:8", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term40.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_6"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term40.gamma_pow|stage6.bytecode_read_raf.claim.term40.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", "field.pow:9", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term41.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_7"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term41.gamma_pow|stage6.bytecode_read_raf.claim.term41.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", "field.pow:10", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term42.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_8"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term42.gamma_pow|stage6.bytecode_read_raf.claim.term42.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", "field.pow:11", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term43.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_9"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term43.gamma_pow|stage6.bytecode_read_raf.claim.term43.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", "field.pow:12", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term44.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_10"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term44.gamma_pow|stage6.bytecode_read_raf.claim.term44.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", "field.pow:13", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term45.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_11"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term45.gamma_pow|stage6.bytecode_read_raf.claim.term45.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", "field.pow:14", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term46.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_12"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term46.gamma_pow|stage6.bytecode_read_raf.claim.term46.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", "field.pow:15", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term47.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_13"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term47.gamma_pow|stage6.bytecode_read_raf.claim.term47.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", "field.pow:16", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term48.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_14"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term48.gamma_pow|stage6.bytecode_read_raf.claim.term48.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", "field.pow:17", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term49.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_15"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term49.gamma_pow|stage6.bytecode_read_raf.claim.term49.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", "field.pow:18", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term50.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_16"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term50.gamma_pow|stage6.bytecode_read_raf.claim.term50.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", "field.pow:19", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term51.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_17"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term51.gamma_pow|stage6.bytecode_read_raf.claim.term51.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", "field.pow:20", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term52.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_18"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term52.gamma_pow|stage6.bytecode_read_raf.claim.term52.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", "field.pow:21", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term53.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_19"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term53.gamma_pow|stage6.bytecode_read_raf.claim.term53.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", "field.pow:22", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term54.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_20"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term54.gamma_pow|stage6.bytecode_read_raf.claim.term54.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", "field.pow:23", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term55.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_21"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term55.gamma_pow|stage6.bytecode_read_raf.claim.term55.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", "field.pow:24", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term56.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_22"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term56.gamma_pow|stage6.bytecode_read_raf.claim.term56.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", "field.pow:25", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term57.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_23"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term57.gamma_pow|stage6.bytecode_read_raf.claim.term57.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", "field.pow:26", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term58.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_24"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term58.gamma_pow|stage6.bytecode_read_raf.claim.term58.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", "field.pow:27", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term59.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_25"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term59.gamma_pow|stage6.bytecode_read_raf.claim.term59.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", "field.pow:28", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term60.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_26"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term60.gamma_pow|stage6.bytecode_read_raf.claim.term60.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", "field.pow:29", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term61.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_27"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term61.gamma_pow|stage6.bytecode_read_raf.claim.term61.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", "field.pow:30", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term62.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_28"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term62.gamma_pow|stage6.bytecode_read_raf.claim.term62.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", "field.pow:31", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term63.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_29"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term63.gamma_pow|stage6.bytecode_read_raf.claim.term63.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", "field.pow:32", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term64.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_30"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term64.gamma_pow|stage6.bytecode_read_raf.claim.term64.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", "field.pow:33", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term65.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_31"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term65.gamma_pow|stage6.bytecode_read_raf.claim.term65.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", "field.pow:34", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term66.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_32"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term66.gamma_pow|stage6.bytecode_read_raf.claim.term66.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", "field.pow:35", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term67.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_33"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term67.gamma_pow|stage6.bytecode_read_raf.claim.term67.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", "field.pow:36", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term68.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_34"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term68.gamma_pow|stage6.bytecode_read_raf.claim.term68.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", "field.pow:37", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term69.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_35"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term69.gamma_pow|stage6.bytecode_read_raf.claim.term69.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", "field.pow:38", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term70.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_36"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term70.gamma_pow|stage6.bytecode_read_raf.claim.term70.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", "field.pow:39", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term71.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_37"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term71.gamma_pow|stage6.bytecode_read_raf.claim.term71.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", "field.pow:40", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term72.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_38"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term72.gamma_pow|stage6.bytecode_read_raf.claim.term72.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", "field.pow:41", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term73.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_39"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term73.gamma_pow|stage6.bytecode_read_raf.claim.term73.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", "field.pow:42", "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term74.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_40"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_pow", "field.pow:4", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term74.gamma_pow|stage6.bytecode_read_raf.claim.term74.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_pow", "field.pow:5", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term75.gamma_pow|stage6.input.stage1.PC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_pow", "field.pow:6", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_term", "field.mul", "stage6.bytecode_read_raf.claim.term76.gamma_pow|stage6.input.stage3.spartan_shift.PC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.entry_constant", "field.pow:7", "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial0", "field.add", "stage6.input.stage1.UnexpandedPC|stage6.bytecode_read_raf.claim.term1.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial1", "field.add", "stage6.bytecode_read_raf.claim_expr.partial0|stage6.bytecode_read_raf.claim.term2.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial2", "field.add", "stage6.bytecode_read_raf.claim_expr.partial1|stage6.bytecode_read_raf.claim.term3.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial3", "field.add", "stage6.bytecode_read_raf.claim_expr.partial2|stage6.bytecode_read_raf.claim.term4.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial4", "field.add", "stage6.bytecode_read_raf.claim_expr.partial3|stage6.bytecode_read_raf.claim.term5.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial5", "field.add", "stage6.bytecode_read_raf.claim_expr.partial4|stage6.bytecode_read_raf.claim.term6.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial6", "field.add", "stage6.bytecode_read_raf.claim_expr.partial5|stage6.bytecode_read_raf.claim.term7.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial7", "field.add", "stage6.bytecode_read_raf.claim_expr.partial6|stage6.bytecode_read_raf.claim.term8.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial8", "field.add", "stage6.bytecode_read_raf.claim_expr.partial7|stage6.bytecode_read_raf.claim.term9.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial9", "field.add", "stage6.bytecode_read_raf.claim_expr.partial8|stage6.bytecode_read_raf.claim.term10.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial10", "field.add", "stage6.bytecode_read_raf.claim_expr.partial9|stage6.bytecode_read_raf.claim.term11.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial11", "field.add", "stage6.bytecode_read_raf.claim_expr.partial10|stage6.bytecode_read_raf.claim.term12.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial12", "field.add", "stage6.bytecode_read_raf.claim_expr.partial11|stage6.bytecode_read_raf.claim.term13.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial13", "field.add", "stage6.bytecode_read_raf.claim_expr.partial12|stage6.bytecode_read_raf.claim.term14.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial14", "field.add", "stage6.bytecode_read_raf.claim_expr.partial13|stage6.bytecode_read_raf.claim.term15.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial15", "field.add", "stage6.bytecode_read_raf.claim_expr.partial14|stage6.bytecode_read_raf.claim.term16.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial16", "field.add", "stage6.bytecode_read_raf.claim_expr.partial15|stage6.bytecode_read_raf.claim.term17.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial17", "field.add", "stage6.bytecode_read_raf.claim_expr.partial16|stage6.bytecode_read_raf.claim.term18.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial18", "field.add", "stage6.bytecode_read_raf.claim_expr.partial17|stage6.bytecode_read_raf.claim.term19.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial19", "field.add", "stage6.bytecode_read_raf.claim_expr.partial18|stage6.bytecode_read_raf.claim.term20.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial20", "field.add", "stage6.bytecode_read_raf.claim_expr.partial19|stage6.bytecode_read_raf.claim.term21.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial21", "field.add", "stage6.bytecode_read_raf.claim_expr.partial20|stage6.bytecode_read_raf.claim.term22.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial22", "field.add", "stage6.bytecode_read_raf.claim_expr.partial21|stage6.bytecode_read_raf.claim.term23.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial23", "field.add", "stage6.bytecode_read_raf.claim_expr.partial22|stage6.bytecode_read_raf.claim.term24.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial24", "field.add", "stage6.bytecode_read_raf.claim_expr.partial23|stage6.bytecode_read_raf.claim.term25.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial25", "field.add", "stage6.bytecode_read_raf.claim_expr.partial24|stage6.bytecode_read_raf.claim.term26.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial26", "field.add", "stage6.bytecode_read_raf.claim_expr.partial25|stage6.bytecode_read_raf.claim.term27.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial27", "field.add", "stage6.bytecode_read_raf.claim_expr.partial26|stage6.bytecode_read_raf.claim.term28.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial28", "field.add", "stage6.bytecode_read_raf.claim_expr.partial27|stage6.bytecode_read_raf.claim.term29.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial29", "field.add", "stage6.bytecode_read_raf.claim_expr.partial28|stage6.bytecode_read_raf.claim.term30.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial30", "field.add", "stage6.bytecode_read_raf.claim_expr.partial29|stage6.bytecode_read_raf.claim.term31.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial31", "field.add", "stage6.bytecode_read_raf.claim_expr.partial30|stage6.bytecode_read_raf.claim.term32.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial32", "field.add", "stage6.bytecode_read_raf.claim_expr.partial31|stage6.bytecode_read_raf.claim.term33.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial33", "field.add", "stage6.bytecode_read_raf.claim_expr.partial32|stage6.bytecode_read_raf.claim.term34.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial34", "field.add", "stage6.bytecode_read_raf.claim_expr.partial33|stage6.bytecode_read_raf.claim.term35.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial35", "field.add", "stage6.bytecode_read_raf.claim_expr.partial34|stage6.bytecode_read_raf.claim.term36.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial36", "field.add", "stage6.bytecode_read_raf.claim_expr.partial35|stage6.bytecode_read_raf.claim.term37.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial37", "field.add", "stage6.bytecode_read_raf.claim_expr.partial36|stage6.bytecode_read_raf.claim.term38.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial38", "field.add", "stage6.bytecode_read_raf.claim_expr.partial37|stage6.bytecode_read_raf.claim.term39.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial39", "field.add", "stage6.bytecode_read_raf.claim_expr.partial38|stage6.bytecode_read_raf.claim.term40.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial40", "field.add", "stage6.bytecode_read_raf.claim_expr.partial39|stage6.bytecode_read_raf.claim.term41.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial41", "field.add", "stage6.bytecode_read_raf.claim_expr.partial40|stage6.bytecode_read_raf.claim.term42.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial42", "field.add", "stage6.bytecode_read_raf.claim_expr.partial41|stage6.bytecode_read_raf.claim.term43.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial43", "field.add", "stage6.bytecode_read_raf.claim_expr.partial42|stage6.bytecode_read_raf.claim.term44.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial44", "field.add", "stage6.bytecode_read_raf.claim_expr.partial43|stage6.bytecode_read_raf.claim.term45.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial45", "field.add", "stage6.bytecode_read_raf.claim_expr.partial44|stage6.bytecode_read_raf.claim.term46.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial46", "field.add", "stage6.bytecode_read_raf.claim_expr.partial45|stage6.bytecode_read_raf.claim.term47.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial47", "field.add", "stage6.bytecode_read_raf.claim_expr.partial46|stage6.bytecode_read_raf.claim.term48.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial48", "field.add", "stage6.bytecode_read_raf.claim_expr.partial47|stage6.bytecode_read_raf.claim.term49.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial49", "field.add", "stage6.bytecode_read_raf.claim_expr.partial48|stage6.bytecode_read_raf.claim.term50.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial50", "field.add", "stage6.bytecode_read_raf.claim_expr.partial49|stage6.bytecode_read_raf.claim.term51.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial51", "field.add", "stage6.bytecode_read_raf.claim_expr.partial50|stage6.bytecode_read_raf.claim.term52.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial52", "field.add", "stage6.bytecode_read_raf.claim_expr.partial51|stage6.bytecode_read_raf.claim.term53.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial53", "field.add", "stage6.bytecode_read_raf.claim_expr.partial52|stage6.bytecode_read_raf.claim.term54.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial54", "field.add", "stage6.bytecode_read_raf.claim_expr.partial53|stage6.bytecode_read_raf.claim.term55.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial55", "field.add", "stage6.bytecode_read_raf.claim_expr.partial54|stage6.bytecode_read_raf.claim.term56.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial56", "field.add", "stage6.bytecode_read_raf.claim_expr.partial55|stage6.bytecode_read_raf.claim.term57.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial57", "field.add", "stage6.bytecode_read_raf.claim_expr.partial56|stage6.bytecode_read_raf.claim.term58.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial58", "field.add", "stage6.bytecode_read_raf.claim_expr.partial57|stage6.bytecode_read_raf.claim.term59.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial59", "field.add", "stage6.bytecode_read_raf.claim_expr.partial58|stage6.bytecode_read_raf.claim.term60.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial60", "field.add", "stage6.bytecode_read_raf.claim_expr.partial59|stage6.bytecode_read_raf.claim.term61.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial61", "field.add", "stage6.bytecode_read_raf.claim_expr.partial60|stage6.bytecode_read_raf.claim.term62.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial62", "field.add", "stage6.bytecode_read_raf.claim_expr.partial61|stage6.bytecode_read_raf.claim.term63.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial63", "field.add", "stage6.bytecode_read_raf.claim_expr.partial62|stage6.bytecode_read_raf.claim.term64.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial64", "field.add", "stage6.bytecode_read_raf.claim_expr.partial63|stage6.bytecode_read_raf.claim.term65.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial65", "field.add", "stage6.bytecode_read_raf.claim_expr.partial64|stage6.bytecode_read_raf.claim.term66.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial66", "field.add", "stage6.bytecode_read_raf.claim_expr.partial65|stage6.bytecode_read_raf.claim.term67.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial67", "field.add", "stage6.bytecode_read_raf.claim_expr.partial66|stage6.bytecode_read_raf.claim.term68.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial68", "field.add", "stage6.bytecode_read_raf.claim_expr.partial67|stage6.bytecode_read_raf.claim.term69.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial69", "field.add", "stage6.bytecode_read_raf.claim_expr.partial68|stage6.bytecode_read_raf.claim.term70.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial70", "field.add", "stage6.bytecode_read_raf.claim_expr.partial69|stage6.bytecode_read_raf.claim.term71.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial71", "field.add", "stage6.bytecode_read_raf.claim_expr.partial70|stage6.bytecode_read_raf.claim.term72.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial72", "field.add", "stage6.bytecode_read_raf.claim_expr.partial71|stage6.bytecode_read_raf.claim.term73.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial73", "field.add", "stage6.bytecode_read_raf.claim_expr.partial72|stage6.bytecode_read_raf.claim.term74.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial74", "field.add", "stage6.bytecode_read_raf.claim_expr.partial73|stage6.bytecode_read_raf.claim.term75.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial75", "field.add", "stage6.bytecode_read_raf.claim_expr.partial74|stage6.bytecode_read_raf.claim.term76.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial76", "field.add", "stage6.bytecode_read_raf.claim_expr.partial75|stage6.bytecode_read_raf.claim.entry_constant"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_pow", "field.pow:1", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term1.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_1"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_pow", "field.pow:2", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term2.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_2"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_pow", "field.pow:3", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term3.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_3"), - stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_pow", "field.pow:4", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term4.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_4"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_pow", "field.pow:5", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term5.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_5"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_pow", "field.pow:6", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term6.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_6"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_pow", "field.pow:7", "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_term", "field.mul", "stage6.instruction_ra_virtual.claim.term7.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_7"), - stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial0", "field.add", "stage6.input.stage5.instruction_read_raf.InstructionRa_0|stage6.instruction_ra_virtual.claim.term1.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial1", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial0|stage6.instruction_ra_virtual.claim.term2.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial2", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial1|stage6.instruction_ra_virtual.claim.term3.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial3", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial2|stage6.instruction_ra_virtual.claim.term4.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial4", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial3|stage6.instruction_ra_virtual.claim.term5.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial5", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial4|stage6.instruction_ra_virtual.claim.term6.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial6", "field.add", "stage6.instruction_ra_virtual.claim_expr.partial5|stage6.instruction_ra_virtual.claim.term7.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "field.pow:1", "stage6.inc_claim_reduction.gamma"), - stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", "field.mul", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow|stage6.input.stage4.ram_val_check.RamInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "field.pow:2", "stage6.inc_claim_reduction.gamma"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", "field.mul", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow|stage6.input.stage4.registers_read_write.RdInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "field.pow:3", "stage6.inc_claim_reduction.gamma"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", "field.mul", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow|stage6.input.stage5.registers_val_evaluation.RdInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial0", "field.add", "stage6.input.stage2.ram_read_write.RamInc|stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial1", "field.add", "stage6.inc_claim_reduction.claim_expr.partial0|stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial2", "field.add", "stage6.inc_claim_reduction.claim_expr.partial1|stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"), + stage6_field_expr!("stage6.booleanity.gamma_sq_0", Stage6FieldExprKind::Pow(0), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_1", Stage6FieldExprKind::Pow(2), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_2", Stage6FieldExprKind::Pow(4), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_3", Stage6FieldExprKind::Pow(6), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_4", Stage6FieldExprKind::Pow(8), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_5", Stage6FieldExprKind::Pow(10), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_6", Stage6FieldExprKind::Pow(12), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_7", Stage6FieldExprKind::Pow(14), "stage6.booleanity.gamma"), + stage6_field_expr!("stage6.booleanity.gamma_sq_8", Stage6FieldExprKind::Pow(16), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_9", Stage6FieldExprKind::Pow(18), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_10", Stage6FieldExprKind::Pow(20), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_11", Stage6FieldExprKind::Pow(22), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_12", Stage6FieldExprKind::Pow(24), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_13", Stage6FieldExprKind::Pow(26), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_14", Stage6FieldExprKind::Pow(28), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_15", Stage6FieldExprKind::Pow(30), "stage6.booleanity.gamma"), + stage6_field_expr!("stage6.booleanity.gamma_sq_16", Stage6FieldExprKind::Pow(32), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_17", Stage6FieldExprKind::Pow(34), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_18", Stage6FieldExprKind::Pow(36), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_19", Stage6FieldExprKind::Pow(38), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_20", Stage6FieldExprKind::Pow(40), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_21", Stage6FieldExprKind::Pow(42), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_22", Stage6FieldExprKind::Pow(44), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_23", Stage6FieldExprKind::Pow(46), "stage6.booleanity.gamma"), + stage6_field_expr!("stage6.booleanity.gamma_sq_24", Stage6FieldExprKind::Pow(48), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_25", Stage6FieldExprKind::Pow(50), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_26", Stage6FieldExprKind::Pow(52), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_27", Stage6FieldExprKind::Pow(54), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_28", Stage6FieldExprKind::Pow(56), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_29", Stage6FieldExprKind::Pow(58), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_30", Stage6FieldExprKind::Pow(60), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_31", Stage6FieldExprKind::Pow(62), "stage6.booleanity.gamma"), + stage6_field_expr!("stage6.booleanity.gamma_sq_32", Stage6FieldExprKind::Pow(64), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_33", Stage6FieldExprKind::Pow(66), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_34", Stage6FieldExprKind::Pow(68), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_35", Stage6FieldExprKind::Pow(70), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_36", Stage6FieldExprKind::Pow(72), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_37", Stage6FieldExprKind::Pow(74), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_38", Stage6FieldExprKind::Pow(76), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_0", Stage6FieldExprKind::Pow(0), "stage6.booleanity.gamma"), + stage6_field_expr!("stage6.booleanity.gamma_pow_1", Stage6FieldExprKind::Pow(1), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_2", Stage6FieldExprKind::Pow(2), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_3", Stage6FieldExprKind::Pow(3), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_4", Stage6FieldExprKind::Pow(4), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_5", Stage6FieldExprKind::Pow(5), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_6", Stage6FieldExprKind::Pow(6), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_7", Stage6FieldExprKind::Pow(7), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_8", Stage6FieldExprKind::Pow(8), "stage6.booleanity.gamma"), + stage6_field_expr!("stage6.booleanity.gamma_pow_9", Stage6FieldExprKind::Pow(9), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_10", Stage6FieldExprKind::Pow(10), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_11", Stage6FieldExprKind::Pow(11), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_12", Stage6FieldExprKind::Pow(12), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_13", Stage6FieldExprKind::Pow(13), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_14", Stage6FieldExprKind::Pow(14), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_15", Stage6FieldExprKind::Pow(15), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_16", Stage6FieldExprKind::Pow(16), "stage6.booleanity.gamma"), + stage6_field_expr!("stage6.booleanity.gamma_pow_17", Stage6FieldExprKind::Pow(17), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_18", Stage6FieldExprKind::Pow(18), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_19", Stage6FieldExprKind::Pow(19), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_20", Stage6FieldExprKind::Pow(20), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_21", Stage6FieldExprKind::Pow(21), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_22", Stage6FieldExprKind::Pow(22), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_23", Stage6FieldExprKind::Pow(23), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_24", Stage6FieldExprKind::Pow(24), "stage6.booleanity.gamma"), + stage6_field_expr!("stage6.booleanity.gamma_pow_25", Stage6FieldExprKind::Pow(25), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_26", Stage6FieldExprKind::Pow(26), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_27", Stage6FieldExprKind::Pow(27), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_28", Stage6FieldExprKind::Pow(28), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_29", Stage6FieldExprKind::Pow(29), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_30", Stage6FieldExprKind::Pow(30), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_31", Stage6FieldExprKind::Pow(31), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_32", Stage6FieldExprKind::Pow(32), "stage6.booleanity.gamma"), + stage6_field_expr!("stage6.booleanity.gamma_pow_33", Stage6FieldExprKind::Pow(33), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_34", Stage6FieldExprKind::Pow(34), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_35", Stage6FieldExprKind::Pow(35), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_36", Stage6FieldExprKind::Pow(36), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_37", Stage6FieldExprKind::Pow(37), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_38", Stage6FieldExprKind::Pow(38), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term1.stage_gamma_pow|stage6.input.stage1.Imm"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term2.stage_gamma_pow|stage6.input.stage1.OpFlagAddOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term3.stage_gamma_pow|stage6.input.stage1.OpFlagSubtractOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term4.stage_gamma_pow|stage6.input.stage1.OpFlagMultiplyOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", Stage6FieldExprKind::Pow(5), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term5.stage_gamma_pow|stage6.input.stage1.OpFlagLoad"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", Stage6FieldExprKind::Pow(6), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term6.stage_gamma_pow|stage6.input.stage1.OpFlagStore"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", Stage6FieldExprKind::Pow(7), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term7.stage_gamma_pow|stage6.input.stage1.OpFlagJump"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", Stage6FieldExprKind::Pow(8), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term8.stage_gamma_pow|stage6.input.stage1.OpFlagWriteLookupOutputToRD"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", Stage6FieldExprKind::Pow(9), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term9.stage_gamma_pow|stage6.input.stage1.OpFlagVirtualInstruction"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", Stage6FieldExprKind::Pow(10), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term10.stage_gamma_pow|stage6.input.stage1.OpFlagAssert"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", Stage6FieldExprKind::Pow(11), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term11.stage_gamma_pow|stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", Stage6FieldExprKind::Pow(12), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term12.stage_gamma_pow|stage6.input.stage1.OpFlagAdvice"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", Stage6FieldExprKind::Pow(13), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term13.stage_gamma_pow|stage6.input.stage1.OpFlagIsCompressed"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", Stage6FieldExprKind::Pow(14), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term14.stage_gamma_pow|stage6.input.stage1.OpFlagIsFirstInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", Stage6FieldExprKind::Pow(15), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term15.stage_gamma_pow|stage6.input.stage1.OpFlagIsLastInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term16.gamma_pow|stage6.input.stage2.OpFlagJump"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term17.stage_gamma_pow|stage6.input.stage2.InstructionFlagBranch"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term17.gamma_pow|stage6.bytecode_read_raf.claim.term17.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term18.stage_gamma_pow|stage6.input.stage2.OpFlagWriteLookupOutputToRD"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term18.gamma_pow|stage6.bytecode_read_raf.claim.term18.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term19.stage_gamma_pow|stage6.input.stage2.OpFlagVirtualInstruction"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term19.gamma_pow|stage6.bytecode_read_raf.claim.term19.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term20.gamma_pow|stage6.input.stage3.instruction_input.Imm"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term21.stage_gamma_pow|stage6.input.stage3.spartan_shift.UnexpandedPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term21.gamma_pow|stage6.bytecode_read_raf.claim.term21.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term22.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term22.gamma_pow|stage6.bytecode_read_raf.claim.term22.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term23.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term23.gamma_pow|stage6.bytecode_read_raf.claim.term23.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term24.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term24.gamma_pow|stage6.bytecode_read_raf.claim.term24.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", Stage6FieldExprKind::Pow(5), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term25.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term25.gamma_pow|stage6.bytecode_read_raf.claim.term25.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", Stage6FieldExprKind::Pow(6), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term26.stage_gamma_pow|stage6.input.stage3.spartan_shift.InstructionFlagIsNoop"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term26.gamma_pow|stage6.bytecode_read_raf.claim.term26.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", Stage6FieldExprKind::Pow(7), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term27.stage_gamma_pow|stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term27.gamma_pow|stage6.bytecode_read_raf.claim.term27.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", Stage6FieldExprKind::Pow(8), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term28.stage_gamma_pow|stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term28.gamma_pow|stage6.bytecode_read_raf.claim.term28.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term29.gamma_pow|stage6.input.stage4.RdWa"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.stage4_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term30.stage_gamma_pow|stage6.input.stage4.Rs1Ra"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term30.gamma_pow|stage6.bytecode_read_raf.claim.term30.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.stage4_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term31.stage_gamma_pow|stage6.input.stage4.Rs2Ra"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term31.gamma_pow|stage6.bytecode_read_raf.claim.term31.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term32.gamma_pow|stage6.input.stage5.registers_val_evaluation.RdWa"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term33.stage_gamma_pow|stage6.input.stage5.InstructionRafFlag"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term33.gamma_pow|stage6.bytecode_read_raf.claim.term33.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term34.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_0"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term34.gamma_pow|stage6.bytecode_read_raf.claim.term34.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term35.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_1"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term35.gamma_pow|stage6.bytecode_read_raf.claim.term35.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term36.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_2"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term36.gamma_pow|stage6.bytecode_read_raf.claim.term36.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", Stage6FieldExprKind::Pow(5), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term37.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_3"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term37.gamma_pow|stage6.bytecode_read_raf.claim.term37.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", Stage6FieldExprKind::Pow(6), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term38.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_4"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term38.gamma_pow|stage6.bytecode_read_raf.claim.term38.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", Stage6FieldExprKind::Pow(7), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term39.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_5"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term39.gamma_pow|stage6.bytecode_read_raf.claim.term39.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", Stage6FieldExprKind::Pow(8), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term40.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_6"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term40.gamma_pow|stage6.bytecode_read_raf.claim.term40.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", Stage6FieldExprKind::Pow(9), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term41.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_7"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term41.gamma_pow|stage6.bytecode_read_raf.claim.term41.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", Stage6FieldExprKind::Pow(10), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term42.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_8"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term42.gamma_pow|stage6.bytecode_read_raf.claim.term42.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", Stage6FieldExprKind::Pow(11), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term43.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_9"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term43.gamma_pow|stage6.bytecode_read_raf.claim.term43.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", Stage6FieldExprKind::Pow(12), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term44.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_10"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term44.gamma_pow|stage6.bytecode_read_raf.claim.term44.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", Stage6FieldExprKind::Pow(13), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term45.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_11"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term45.gamma_pow|stage6.bytecode_read_raf.claim.term45.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", Stage6FieldExprKind::Pow(14), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term46.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_12"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term46.gamma_pow|stage6.bytecode_read_raf.claim.term46.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", Stage6FieldExprKind::Pow(15), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term47.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_13"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term47.gamma_pow|stage6.bytecode_read_raf.claim.term47.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", Stage6FieldExprKind::Pow(16), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term48.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_14"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term48.gamma_pow|stage6.bytecode_read_raf.claim.term48.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", Stage6FieldExprKind::Pow(17), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term49.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_15"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term49.gamma_pow|stage6.bytecode_read_raf.claim.term49.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", Stage6FieldExprKind::Pow(18), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term50.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_16"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term50.gamma_pow|stage6.bytecode_read_raf.claim.term50.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", Stage6FieldExprKind::Pow(19), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term51.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_17"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term51.gamma_pow|stage6.bytecode_read_raf.claim.term51.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", Stage6FieldExprKind::Pow(20), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term52.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_18"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term52.gamma_pow|stage6.bytecode_read_raf.claim.term52.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", Stage6FieldExprKind::Pow(21), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term53.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_19"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term53.gamma_pow|stage6.bytecode_read_raf.claim.term53.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", Stage6FieldExprKind::Pow(22), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term54.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_20"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term54.gamma_pow|stage6.bytecode_read_raf.claim.term54.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", Stage6FieldExprKind::Pow(23), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term55.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_21"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term55.gamma_pow|stage6.bytecode_read_raf.claim.term55.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", Stage6FieldExprKind::Pow(24), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term56.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_22"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term56.gamma_pow|stage6.bytecode_read_raf.claim.term56.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", Stage6FieldExprKind::Pow(25), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term57.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_23"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term57.gamma_pow|stage6.bytecode_read_raf.claim.term57.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", Stage6FieldExprKind::Pow(26), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term58.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_24"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term58.gamma_pow|stage6.bytecode_read_raf.claim.term58.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", Stage6FieldExprKind::Pow(27), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term59.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_25"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term59.gamma_pow|stage6.bytecode_read_raf.claim.term59.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", Stage6FieldExprKind::Pow(28), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term60.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_26"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term60.gamma_pow|stage6.bytecode_read_raf.claim.term60.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", Stage6FieldExprKind::Pow(29), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term61.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_27"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term61.gamma_pow|stage6.bytecode_read_raf.claim.term61.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", Stage6FieldExprKind::Pow(30), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term62.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_28"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term62.gamma_pow|stage6.bytecode_read_raf.claim.term62.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", Stage6FieldExprKind::Pow(31), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term63.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_29"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term63.gamma_pow|stage6.bytecode_read_raf.claim.term63.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", Stage6FieldExprKind::Pow(32), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term64.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_30"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term64.gamma_pow|stage6.bytecode_read_raf.claim.term64.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", Stage6FieldExprKind::Pow(33), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term65.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_31"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term65.gamma_pow|stage6.bytecode_read_raf.claim.term65.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", Stage6FieldExprKind::Pow(34), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term66.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_32"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term66.gamma_pow|stage6.bytecode_read_raf.claim.term66.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", Stage6FieldExprKind::Pow(35), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term67.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_33"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term67.gamma_pow|stage6.bytecode_read_raf.claim.term67.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", Stage6FieldExprKind::Pow(36), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term68.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_34"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term68.gamma_pow|stage6.bytecode_read_raf.claim.term68.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", Stage6FieldExprKind::Pow(37), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term69.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_35"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term69.gamma_pow|stage6.bytecode_read_raf.claim.term69.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", Stage6FieldExprKind::Pow(38), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term70.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_36"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term70.gamma_pow|stage6.bytecode_read_raf.claim.term70.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", Stage6FieldExprKind::Pow(39), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term71.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_37"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term71.gamma_pow|stage6.bytecode_read_raf.claim.term71.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", Stage6FieldExprKind::Pow(40), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term72.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_38"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term72.gamma_pow|stage6.bytecode_read_raf.claim.term72.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", Stage6FieldExprKind::Pow(41), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term73.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_39"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term73.gamma_pow|stage6.bytecode_read_raf.claim.term73.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", Stage6FieldExprKind::Pow(42), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term74.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_40"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term74.gamma_pow|stage6.bytecode_read_raf.claim.term74.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_pow", Stage6FieldExprKind::Pow(5), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term75.gamma_pow|stage6.input.stage1.PC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_pow", Stage6FieldExprKind::Pow(6), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term76.gamma_pow|stage6.input.stage3.spartan_shift.PC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.entry_constant", Stage6FieldExprKind::Pow(7), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial0", Stage6FieldExprKind::Add, "stage6.input.stage1.UnexpandedPC|stage6.bytecode_read_raf.claim.term1.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial1", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial0|stage6.bytecode_read_raf.claim.term2.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial2", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial1|stage6.bytecode_read_raf.claim.term3.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial3", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial2|stage6.bytecode_read_raf.claim.term4.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial4", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial3|stage6.bytecode_read_raf.claim.term5.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial5", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial4|stage6.bytecode_read_raf.claim.term6.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial6", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial5|stage6.bytecode_read_raf.claim.term7.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial7", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial6|stage6.bytecode_read_raf.claim.term8.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial8", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial7|stage6.bytecode_read_raf.claim.term9.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial9", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial8|stage6.bytecode_read_raf.claim.term10.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial10", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial9|stage6.bytecode_read_raf.claim.term11.stage_gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial11", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial10|stage6.bytecode_read_raf.claim.term12.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial12", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial11|stage6.bytecode_read_raf.claim.term13.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial13", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial12|stage6.bytecode_read_raf.claim.term14.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial14", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial13|stage6.bytecode_read_raf.claim.term15.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial15", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial14|stage6.bytecode_read_raf.claim.term16.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial16", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial15|stage6.bytecode_read_raf.claim.term17.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial17", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial16|stage6.bytecode_read_raf.claim.term18.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial18", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial17|stage6.bytecode_read_raf.claim.term19.gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial19", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial18|stage6.bytecode_read_raf.claim.term20.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial20", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial19|stage6.bytecode_read_raf.claim.term21.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial21", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial20|stage6.bytecode_read_raf.claim.term22.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial22", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial21|stage6.bytecode_read_raf.claim.term23.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial23", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial22|stage6.bytecode_read_raf.claim.term24.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial24", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial23|stage6.bytecode_read_raf.claim.term25.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial25", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial24|stage6.bytecode_read_raf.claim.term26.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial26", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial25|stage6.bytecode_read_raf.claim.term27.gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial27", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial26|stage6.bytecode_read_raf.claim.term28.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial28", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial27|stage6.bytecode_read_raf.claim.term29.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial29", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial28|stage6.bytecode_read_raf.claim.term30.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial30", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial29|stage6.bytecode_read_raf.claim.term31.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial31", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial30|stage6.bytecode_read_raf.claim.term32.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial32", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial31|stage6.bytecode_read_raf.claim.term33.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial33", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial32|stage6.bytecode_read_raf.claim.term34.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial34", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial33|stage6.bytecode_read_raf.claim.term35.gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial35", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial34|stage6.bytecode_read_raf.claim.term36.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial36", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial35|stage6.bytecode_read_raf.claim.term37.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial37", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial36|stage6.bytecode_read_raf.claim.term38.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial38", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial37|stage6.bytecode_read_raf.claim.term39.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial39", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial38|stage6.bytecode_read_raf.claim.term40.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial40", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial39|stage6.bytecode_read_raf.claim.term41.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial41", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial40|stage6.bytecode_read_raf.claim.term42.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial42", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial41|stage6.bytecode_read_raf.claim.term43.gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial43", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial42|stage6.bytecode_read_raf.claim.term44.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial44", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial43|stage6.bytecode_read_raf.claim.term45.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial45", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial44|stage6.bytecode_read_raf.claim.term46.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial46", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial45|stage6.bytecode_read_raf.claim.term47.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial47", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial46|stage6.bytecode_read_raf.claim.term48.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial48", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial47|stage6.bytecode_read_raf.claim.term49.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial49", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial48|stage6.bytecode_read_raf.claim.term50.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial50", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial49|stage6.bytecode_read_raf.claim.term51.gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial51", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial50|stage6.bytecode_read_raf.claim.term52.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial52", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial51|stage6.bytecode_read_raf.claim.term53.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial53", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial52|stage6.bytecode_read_raf.claim.term54.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial54", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial53|stage6.bytecode_read_raf.claim.term55.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial55", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial54|stage6.bytecode_read_raf.claim.term56.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial56", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial55|stage6.bytecode_read_raf.claim.term57.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial57", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial56|stage6.bytecode_read_raf.claim.term58.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial58", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial57|stage6.bytecode_read_raf.claim.term59.gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial59", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial58|stage6.bytecode_read_raf.claim.term60.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial60", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial59|stage6.bytecode_read_raf.claim.term61.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial61", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial60|stage6.bytecode_read_raf.claim.term62.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial62", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial61|stage6.bytecode_read_raf.claim.term63.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial63", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial62|stage6.bytecode_read_raf.claim.term64.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial64", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial63|stage6.bytecode_read_raf.claim.term65.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial65", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial64|stage6.bytecode_read_raf.claim.term66.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial66", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial65|stage6.bytecode_read_raf.claim.term67.gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial67", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial66|stage6.bytecode_read_raf.claim.term68.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial68", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial67|stage6.bytecode_read_raf.claim.term69.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial69", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial68|stage6.bytecode_read_raf.claim.term70.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial70", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial69|stage6.bytecode_read_raf.claim.term71.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial71", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial70|stage6.bytecode_read_raf.claim.term72.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial72", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial71|stage6.bytecode_read_raf.claim.term73.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial73", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial72|stage6.bytecode_read_raf.claim.term74.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial74", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial73|stage6.bytecode_read_raf.claim.term75.gamma_term"), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial75", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial74|stage6.bytecode_read_raf.claim.term76.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial76", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial75|stage6.bytecode_read_raf.claim.entry_constant"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term1.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_1"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term2.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_2"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term3.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_3"), + stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term4.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_4"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term5.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_5"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term6.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_6"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term7.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_7"), + stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, "stage6.input.stage5.instruction_read_raf.InstructionRa_0|stage6.instruction_ra_virtual.claim.term1.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial0|stage6.instruction_ra_virtual.claim.term2.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial1|stage6.instruction_ra_virtual.claim.term3.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial2|stage6.instruction_ra_virtual.claim.term4.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial3|stage6.instruction_ra_virtual.claim.term5.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial4|stage6.instruction_ra_virtual.claim.term6.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial5|stage6.instruction_ra_virtual.claim.term7.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.inc_claim_reduction.gamma"), + stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow|stage6.input.stage4.ram_val_check.RamInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.inc_claim_reduction.gamma"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow|stage6.input.stage4.registers_read_write.RdInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.inc_claim_reduction.gamma"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow|stage6.input.stage5.registers_val_evaluation.RdInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, "stage6.input.stage2.ram_read_write.RamInc|stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, "stage6.inc_claim_reduction.claim_expr.partial0|stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, "stage6.inc_claim_reduction.claim_expr.partial1|stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ ]; pub const STAGE6_SUMCHECK_CLAIMS: &[Stage6SumcheckClaimPlan] = &[ - Stage6SumcheckClaimPlan { symbol: "stage6.bytecode_read_raf.input", stage: "stage6", domain: "jolt.stage6_bytecode_read_raf_domain", num_rounds: 26, degree: 4, claim: "stage6.bytecode_read_raf.weighted_prior_stage_values", kernel: None, relation: Some("jolt.stage6.bytecode_read_raf"), claim_value: "stage6.bytecode_read_raf.claim_expr.partial76", input_openings: "stage6.input.stage1.UnexpandedPC|stage6.input.stage1.Imm|stage6.input.stage1.OpFlagAddOperands|stage6.input.stage1.OpFlagSubtractOperands|stage6.input.stage1.OpFlagMultiplyOperands|stage6.input.stage1.OpFlagLoad|stage6.input.stage1.OpFlagStore|stage6.input.stage1.OpFlagJump|stage6.input.stage1.OpFlagWriteLookupOutputToRD|stage6.input.stage1.OpFlagVirtualInstruction|stage6.input.stage1.OpFlagAssert|stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC|stage6.input.stage1.OpFlagAdvice|stage6.input.stage1.OpFlagIsCompressed|stage6.input.stage1.OpFlagIsFirstInSequence|stage6.input.stage1.OpFlagIsLastInSequence|stage6.input.stage2.OpFlagJump|stage6.input.stage2.InstructionFlagBranch|stage6.input.stage2.OpFlagWriteLookupOutputToRD|stage6.input.stage2.OpFlagVirtualInstruction|stage6.input.stage3.instruction_input.Imm|stage6.input.stage3.spartan_shift.UnexpandedPC|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm|stage6.input.stage3.spartan_shift.InstructionFlagIsNoop|stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction|stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence|stage6.input.stage4.RdWa|stage6.input.stage4.Rs1Ra|stage6.input.stage4.Rs2Ra|stage6.input.stage5.registers_val_evaluation.RdWa|stage6.input.stage5.InstructionRafFlag|stage6.input.stage5.LookupTableFlag_0|stage6.input.stage5.LookupTableFlag_1|stage6.input.stage5.LookupTableFlag_2|stage6.input.stage5.LookupTableFlag_3|stage6.input.stage5.LookupTableFlag_4|stage6.input.stage5.LookupTableFlag_5|stage6.input.stage5.LookupTableFlag_6|stage6.input.stage5.LookupTableFlag_7|stage6.input.stage5.LookupTableFlag_8|stage6.input.stage5.LookupTableFlag_9|stage6.input.stage5.LookupTableFlag_10|stage6.input.stage5.LookupTableFlag_11|stage6.input.stage5.LookupTableFlag_12|stage6.input.stage5.LookupTableFlag_13|stage6.input.stage5.LookupTableFlag_14|stage6.input.stage5.LookupTableFlag_15|stage6.input.stage5.LookupTableFlag_16|stage6.input.stage5.LookupTableFlag_17|stage6.input.stage5.LookupTableFlag_18|stage6.input.stage5.LookupTableFlag_19|stage6.input.stage5.LookupTableFlag_20|stage6.input.stage5.LookupTableFlag_21|stage6.input.stage5.LookupTableFlag_22|stage6.input.stage5.LookupTableFlag_23|stage6.input.stage5.LookupTableFlag_24|stage6.input.stage5.LookupTableFlag_25|stage6.input.stage5.LookupTableFlag_26|stage6.input.stage5.LookupTableFlag_27|stage6.input.stage5.LookupTableFlag_28|stage6.input.stage5.LookupTableFlag_29|stage6.input.stage5.LookupTableFlag_30|stage6.input.stage5.LookupTableFlag_31|stage6.input.stage5.LookupTableFlag_32|stage6.input.stage5.LookupTableFlag_33|stage6.input.stage5.LookupTableFlag_34|stage6.input.stage5.LookupTableFlag_35|stage6.input.stage5.LookupTableFlag_36|stage6.input.stage5.LookupTableFlag_37|stage6.input.stage5.LookupTableFlag_38|stage6.input.stage5.LookupTableFlag_39|stage6.input.stage5.LookupTableFlag_40|stage6.input.stage1.PC|stage6.input.stage3.spartan_shift.PC" }, - Stage6SumcheckClaimPlan { symbol: "stage6.booleanity.input", stage: "stage6", domain: "jolt.stage6_booleanity_domain", num_rounds: 20, degree: 3, claim: "stage6.booleanity.zero", kernel: None, relation: Some("jolt.stage6.booleanity"), claim_value: "stage6.zero", input_openings: "" }, - Stage6SumcheckClaimPlan { symbol: "stage6.hamming_booleanity.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage6.hamming_booleanity.zero", kernel: None, relation: Some("jolt.stage6.hamming_booleanity"), claim_value: "stage6.zero", input_openings: "stage6.input.stage1.LookupOutput" }, - Stage6SumcheckClaimPlan { symbol: "stage6.ram_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.ram_ra_virtual.weighted_ram_ra", kernel: None, relation: Some("jolt.stage6.ram_ra_virtual"), claim_value: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", input_openings: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" }, - Stage6SumcheckClaimPlan { symbol: "stage6.instruction_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.instruction_ra_virtual.weighted_instruction_ra", kernel: None, relation: Some("jolt.stage6.instruction_ra_virtual"), claim_value: "stage6.instruction_ra_virtual.claim_expr.partial6", input_openings: "stage6.input.stage5.instruction_read_raf.InstructionRa_0|stage6.input.stage5.instruction_read_raf.InstructionRa_1|stage6.input.stage5.instruction_read_raf.InstructionRa_2|stage6.input.stage5.instruction_read_raf.InstructionRa_3|stage6.input.stage5.instruction_read_raf.InstructionRa_4|stage6.input.stage5.instruction_read_raf.InstructionRa_5|stage6.input.stage5.instruction_read_raf.InstructionRa_6|stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, - Stage6SumcheckClaimPlan { symbol: "stage6.inc_claim_reduction.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage6.inc_claim_reduction.weighted_increments", kernel: None, relation: Some("jolt.stage6.inc_claim_reduction"), claim_value: "stage6.inc_claim_reduction.claim_expr.partial2", input_openings: "stage6.input.stage2.ram_read_write.RamInc|stage6.input.stage4.ram_val_check.RamInc|stage6.input.stage4.registers_read_write.RdInc|stage6.input.stage5.registers_val_evaluation.RdInc" }, -]; -pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 10, - 16, + Stage6SumcheckClaimPlan { symbol: "stage6.bytecode_read_raf.input", stage: "stage6", domain: "jolt.stage6_bytecode_read_raf_domain", num_rounds: 26, degree: 4, claim: "stage6.bytecode_read_raf.weighted_prior_stage_values", kernel: None, relation: Some(Stage6RelationKind::Stage6BytecodeReadRaf), claim_value: "stage6.bytecode_read_raf.claim_expr.partial76", input_openings: "stage6.input.stage1.UnexpandedPC|stage6.input.stage1.Imm|stage6.input.stage1.OpFlagAddOperands|stage6.input.stage1.OpFlagSubtractOperands|stage6.input.stage1.OpFlagMultiplyOperands|stage6.input.stage1.OpFlagLoad|stage6.input.stage1.OpFlagStore|stage6.input.stage1.OpFlagJump|stage6.input.stage1.OpFlagWriteLookupOutputToRD|stage6.input.stage1.OpFlagVirtualInstruction|stage6.input.stage1.OpFlagAssert|stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC|stage6.input.stage1.OpFlagAdvice|stage6.input.stage1.OpFlagIsCompressed|stage6.input.stage1.OpFlagIsFirstInSequence|stage6.input.stage1.OpFlagIsLastInSequence|stage6.input.stage2.OpFlagJump|stage6.input.stage2.InstructionFlagBranch|stage6.input.stage2.OpFlagWriteLookupOutputToRD|stage6.input.stage2.OpFlagVirtualInstruction|stage6.input.stage3.instruction_input.Imm|stage6.input.stage3.spartan_shift.UnexpandedPC|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm|stage6.input.stage3.spartan_shift.InstructionFlagIsNoop|stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction|stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence|stage6.input.stage4.RdWa|stage6.input.stage4.Rs1Ra|stage6.input.stage4.Rs2Ra|stage6.input.stage5.registers_val_evaluation.RdWa|stage6.input.stage5.InstructionRafFlag|stage6.input.stage5.LookupTableFlag_0|stage6.input.stage5.LookupTableFlag_1|stage6.input.stage5.LookupTableFlag_2|stage6.input.stage5.LookupTableFlag_3|stage6.input.stage5.LookupTableFlag_4|stage6.input.stage5.LookupTableFlag_5|stage6.input.stage5.LookupTableFlag_6|stage6.input.stage5.LookupTableFlag_7|stage6.input.stage5.LookupTableFlag_8|stage6.input.stage5.LookupTableFlag_9|stage6.input.stage5.LookupTableFlag_10|stage6.input.stage5.LookupTableFlag_11|stage6.input.stage5.LookupTableFlag_12|stage6.input.stage5.LookupTableFlag_13|stage6.input.stage5.LookupTableFlag_14|stage6.input.stage5.LookupTableFlag_15|stage6.input.stage5.LookupTableFlag_16|stage6.input.stage5.LookupTableFlag_17|stage6.input.stage5.LookupTableFlag_18|stage6.input.stage5.LookupTableFlag_19|stage6.input.stage5.LookupTableFlag_20|stage6.input.stage5.LookupTableFlag_21|stage6.input.stage5.LookupTableFlag_22|stage6.input.stage5.LookupTableFlag_23|stage6.input.stage5.LookupTableFlag_24|stage6.input.stage5.LookupTableFlag_25|stage6.input.stage5.LookupTableFlag_26|stage6.input.stage5.LookupTableFlag_27|stage6.input.stage5.LookupTableFlag_28|stage6.input.stage5.LookupTableFlag_29|stage6.input.stage5.LookupTableFlag_30|stage6.input.stage5.LookupTableFlag_31|stage6.input.stage5.LookupTableFlag_32|stage6.input.stage5.LookupTableFlag_33|stage6.input.stage5.LookupTableFlag_34|stage6.input.stage5.LookupTableFlag_35|stage6.input.stage5.LookupTableFlag_36|stage6.input.stage5.LookupTableFlag_37|stage6.input.stage5.LookupTableFlag_38|stage6.input.stage5.LookupTableFlag_39|stage6.input.stage5.LookupTableFlag_40|stage6.input.stage1.PC|stage6.input.stage3.spartan_shift.PC" }, + Stage6SumcheckClaimPlan { symbol: "stage6.booleanity.input", stage: "stage6", domain: "jolt.stage6_booleanity_domain", num_rounds: 20, degree: 3, claim: "stage6.booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6Booleanity), claim_value: "stage6.zero", input_openings: "" }, + Stage6SumcheckClaimPlan { symbol: "stage6.hamming_booleanity.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage6.hamming_booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6HammingBooleanity), claim_value: "stage6.zero", input_openings: "stage6.input.stage1.LookupOutput" }, + Stage6SumcheckClaimPlan { symbol: "stage6.ram_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.ram_ra_virtual.weighted_ram_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6RamRaVirtual), claim_value: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", input_openings: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" }, + Stage6SumcheckClaimPlan { symbol: "stage6.instruction_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.instruction_ra_virtual.weighted_instruction_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6InstructionRaVirtual), claim_value: "stage6.instruction_ra_virtual.claim_expr.partial6", input_openings: "stage6.input.stage5.instruction_read_raf.InstructionRa_0|stage6.input.stage5.instruction_read_raf.InstructionRa_1|stage6.input.stage5.instruction_read_raf.InstructionRa_2|stage6.input.stage5.instruction_read_raf.InstructionRa_3|stage6.input.stage5.instruction_read_raf.InstructionRa_4|stage6.input.stage5.instruction_read_raf.InstructionRa_5|stage6.input.stage5.instruction_read_raf.InstructionRa_6|stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, + Stage6SumcheckClaimPlan { symbol: "stage6.inc_claim_reduction.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage6.inc_claim_reduction.weighted_increments", kernel: None, relation: Some(Stage6RelationKind::Stage6IncClaimReduction), claim_value: "stage6.inc_claim_reduction.claim_expr.partial2", input_openings: "stage6.input.stage2.ram_read_write.RamInc|stage6.input.stage4.ram_val_check.RamInc|stage6.input.stage4.registers_read_write.RdInc|stage6.input.stage5.registers_val_evaluation.RdInc" }, ]; +pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[10, 16]; pub const STAGE6_SUMCHECK_BATCHES: &[Stage6SumcheckBatchPlan] = &[ Stage6SumcheckBatchPlan { symbol: "stage6.batch", stage: "stage6", proof_slot: "stage6.sumcheck", policy: "jolt_core_stage6_aligned", count: 6, ordered_claims: "stage6.bytecode_read_raf.input|stage6.booleanity.input|stage6.hamming_booleanity.input|stage6.ram_ra_virtual.input|stage6.instruction_ra_virtual.input|stage6.inc_claim_reduction.input", claim_operands: "stage6.bytecode_read_raf.input|stage6.booleanity.input|stage6.hamming_booleanity.input|stage6.ram_ra_virtual.input|stage6.instruction_ra_virtual.input|stage6.inc_claim_reduction.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; -pub const STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 10, - 16, -]; +pub const STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[10, 16]; pub const STAGE6_SUMCHECK_DRIVERS: &[Stage6SumcheckDriverPlan] = &[ - Stage6SumcheckDriverPlan { symbol: "stage6.sumcheck", stage: "stage6", proof_slot: "stage6.sumcheck", kernel: None, relation: Some("jolt.stage6.batched"), batch: "stage6.batch", policy: "jolt_core_stage6_aligned", round_schedule: STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 26, degree: 5 }, + Stage6SumcheckDriverPlan { symbol: "stage6.sumcheck", stage: "stage6", proof_slot: "stage6.sumcheck", kernel: None, relation: Some(Stage6RelationKind::Stage6Batched), batch: "stage6.batch", policy: "jolt_core_stage6_aligned", round_schedule: STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 26, degree: 5 }, ]; pub const STAGE6_SUMCHECK_INSTANCE_RESULTS: &[Stage6SumcheckInstanceResultPlan] = &[ - Stage6SumcheckInstanceResultPlan { symbol: "stage6.bytecode_read_raf.instance", source: "stage6.sumcheck", claim: "stage6.bytecode_read_raf.input", relation: "jolt.stage6.bytecode_read_raf", index: 0, point_arity: 26, num_rounds: 26, round_offset: 0, point_order: "bytecode_read_raf", degree: 4 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.booleanity.instance", source: "stage6.sumcheck", claim: "stage6.booleanity.input", relation: "jolt.stage6.booleanity", index: 1, point_arity: 20, num_rounds: 20, round_offset: 6, point_order: "stage6_booleanity", degree: 3 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.hamming_booleanity.instance", source: "stage6.sumcheck", claim: "stage6.hamming_booleanity.input", relation: "jolt.stage6.hamming_booleanity", index: 2, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 3 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.ram_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.ram_ra_virtual.input", relation: "jolt.stage6.ram_ra_virtual", index: 3, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 5 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.instruction_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.instruction_ra_virtual.input", relation: "jolt.stage6.instruction_ra_virtual", index: 4, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 5 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.inc_claim_reduction.instance", source: "stage6.sumcheck", claim: "stage6.inc_claim_reduction.input", relation: "jolt.stage6.inc_claim_reduction", index: 5, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 2 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.bytecode_read_raf.instance", source: "stage6.sumcheck", claim: "stage6.bytecode_read_raf.input", relation: Stage6RelationKind::Stage6BytecodeReadRaf, index: 0, point_arity: 26, num_rounds: 26, round_offset: 0, point_order: "bytecode_read_raf", degree: 4 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.booleanity.instance", source: "stage6.sumcheck", claim: "stage6.booleanity.input", relation: Stage6RelationKind::Stage6Booleanity, index: 1, point_arity: 20, num_rounds: 20, round_offset: 6, point_order: "stage6_booleanity", degree: 3 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.hamming_booleanity.instance", source: "stage6.sumcheck", claim: "stage6.hamming_booleanity.input", relation: Stage6RelationKind::Stage6HammingBooleanity, index: 2, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 3 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.ram_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.ram_ra_virtual.input", relation: Stage6RelationKind::Stage6RamRaVirtual, index: 3, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 5 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.instruction_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.instruction_ra_virtual.input", relation: Stage6RelationKind::Stage6InstructionRaVirtual, index: 4, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 5 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.inc_claim_reduction.instance", source: "stage6.sumcheck", claim: "stage6.inc_claim_reduction.input", relation: Stage6RelationKind::Stage6IncClaimReduction, index: 5, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 2 }, ]; macro_rules! stage6_sumcheck_eval { @@ -505,87 +498,87 @@ pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[ Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_31.address|stage6.instruction_ra_virtual.instance" }, ]; pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[ - Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.bytecode_read_raf.point.BytecodeRa_0", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_0" }, - Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.bytecode_read_raf.point.BytecodeRa_1", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_1" }, - Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.bytecode_read_raf.point.BytecodeRa_2", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_2" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_0" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_1" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_2" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_3" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_4" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_5" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_6" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_7" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_8" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_9" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_10" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_11" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_12" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_13" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_14" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_15" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_16" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_17" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_18" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_19" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_20" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_21" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_22" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_23" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_24" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_25" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_26" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_27" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_28" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_29" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_30" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_31" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_0" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_1" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_2" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_0" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_1" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_2" }, - Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_3" }, - Stage6OpeningClaimPlan { symbol: "stage6.hamming_booleanity.opening.HammingWeight", oracle: "HammingWeight", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual", point_source: "stage6.hamming_booleanity.instance", eval_source: "stage6.hamming_booleanity.eval.HammingWeight" }, - Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.ram_ra_virtual.point.RamRa_0", eval_source: "stage6.ram_ra_virtual.eval.RamRa_0" }, - Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.ram_ra_virtual.point.RamRa_1", eval_source: "stage6.ram_ra_virtual.eval.RamRa_1" }, - Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.ram_ra_virtual.point.RamRa_2", eval_source: "stage6.ram_ra_virtual.eval.RamRa_2" }, - Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.ram_ra_virtual.point.RamRa_3", eval_source: "stage6.ram_ra_virtual.eval.RamRa_3" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_0", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_0" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_1", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_1" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_2", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_2" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_3", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_3" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_4", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_4" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_5", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_5" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_6", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_6" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_7", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_7" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_8", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_8" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_9", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_9" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_10", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_10" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_11", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_11" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_12", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_12" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_13", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_13" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_14", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_14" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_15", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_15" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_16", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_16" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_17", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_17" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_18", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_18" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_19", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_19" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_20", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_20" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_21", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_21" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_22", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_22" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_23", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_23" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_24", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_24" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_25", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_25" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_26", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_26" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_27", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_27" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_28", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_28" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_29", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_29" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_30", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_30" }, - Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.instruction_ra_virtual.point.InstructionRa_31", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_31" }, - Stage6OpeningClaimPlan { symbol: "stage6.inc_claim_reduction.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage6.inc_claim_reduction.instance", eval_source: "stage6.inc_claim_reduction.eval.RamInc" }, - Stage6OpeningClaimPlan { symbol: "stage6.inc_claim_reduction.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "committed", point_source: "stage6.inc_claim_reduction.instance", eval_source: "stage6.inc_claim_reduction.eval.RdInc" }, + Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.bytecode_read_raf.point.BytecodeRa_0", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_0" }, + Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.bytecode_read_raf.point.BytecodeRa_1", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_1" }, + Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.bytecode_read_raf.point.BytecodeRa_2", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_2" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_0" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_1" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_2" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_3" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_4" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_5" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_6" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_7" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_8" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_9" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_10" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_11" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_12" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_13" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_14" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_15" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_16" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_17" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_18" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_19" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_20" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_21" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_22" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_23" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_24" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_25" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_26" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_27" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_28" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_29" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_30" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.InstructionRa_31" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_0" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_1" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.BytecodeRa_2" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_0" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_1" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_2" }, + Stage6OpeningClaimPlan { symbol: "stage6.booleanity.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.booleanity.instance", eval_source: "stage6.booleanity.eval.RamRa_3" }, + Stage6OpeningClaimPlan { symbol: "stage6.hamming_booleanity.opening.HammingWeight", oracle: "HammingWeight", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Virtual, point_source: "stage6.hamming_booleanity.instance", eval_source: "stage6.hamming_booleanity.eval.HammingWeight" }, + Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.ram_ra_virtual.point.RamRa_0", eval_source: "stage6.ram_ra_virtual.eval.RamRa_0" }, + Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.ram_ra_virtual.point.RamRa_1", eval_source: "stage6.ram_ra_virtual.eval.RamRa_1" }, + Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.ram_ra_virtual.point.RamRa_2", eval_source: "stage6.ram_ra_virtual.eval.RamRa_2" }, + Stage6OpeningClaimPlan { symbol: "stage6.ram_ra_virtual.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.ram_ra_virtual.point.RamRa_3", eval_source: "stage6.ram_ra_virtual.eval.RamRa_3" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_0", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_0" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_1", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_1" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_2", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_2" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_3", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_3" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_4", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_4" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_5", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_5" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_6", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_6" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_7", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_7" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_8", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_8" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_9", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_9" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_10", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_10" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_11", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_11" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_12", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_12" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_13", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_13" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_14", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_14" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_15", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_15" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_16", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_16" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_17", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_17" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_18", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_18" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_19", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_19" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_20", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_20" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_21", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_21" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_22", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_22" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_23", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_23" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_24", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_24" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_25", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_25" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_26", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_26" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_27", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_27" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_28", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_28" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_29", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_29" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_30", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_30" }, + Stage6OpeningClaimPlan { symbol: "stage6.instruction_ra_virtual.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.instruction_ra_virtual.point.InstructionRa_31", eval_source: "stage6.instruction_ra_virtual.eval.InstructionRa_31" }, + Stage6OpeningClaimPlan { symbol: "stage6.inc_claim_reduction.opening.RamInc", oracle: "RamInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.inc_claim_reduction.instance", eval_source: "stage6.inc_claim_reduction.eval.RamInc" }, + Stage6OpeningClaimPlan { symbol: "stage6.inc_claim_reduction.opening.RdInc", oracle: "RdInc", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.inc_claim_reduction.instance", eval_source: "stage6.inc_claim_reduction.eval.RdInc" }, ]; pub const STAGE6_OPENING_EQUALITIES: &[Stage6OpeningClaimEqualityPlan] = &[ @@ -653,14 +646,14 @@ where let mut artifacts = Stage6ExecutionArtifacts::default(); for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage6ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage6Error::MissingValue { symbol: step.symbol, })?; verify_stage6_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "transcript_absorb_bytes" => { + Stage6ProgramStepKind::TranscriptAbsorbBytes => { let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or( VerifyStage6Error::MissingValue { symbol: step.symbol, @@ -668,7 +661,7 @@ where )?; absorb_stage6_bytes(absorb, transcript); } - "sumcheck_driver" => { + Stage6ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage6Error::MissingProof { driver: step.symbol, @@ -683,12 +676,6 @@ where &mut artifacts, )?; } - _ => { - return Err(VerifyStage6Error::InvalidProof { - driver: step.symbol, - reason: "unsupported stage6 program step", - }); - } } } artifacts @@ -762,12 +749,17 @@ where .ok_or(VerifyStage6Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage6Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage6.batched" => { + Stage6RelationKind::Stage6Batched => { verify_batched_stage6(program, driver, proof, verifier_data, store, transcript)? } - _ => return Err(VerifyStage6Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); Ok(()) @@ -890,9 +882,14 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let relation = claim.relation.unwrap_or(""); + let Some(relation) = claim.relation else { + return Err(VerifyStage6Error::InvalidProof { + driver: driver.symbol, + reason: "missing claim relation", + }); + }; let value = match relation { - "jolt.stage6.bytecode_read_raf" => { + Stage6RelationKind::Stage6BytecodeReadRaf => { let data = verifier_data .and_then(|data| data.bytecode_read_raf.as_ref()) .ok_or(VerifyStage6Error::MissingValue { @@ -900,22 +897,22 @@ fn expected_batched_output_claim( })?; expected_bytecode_read_raf(program, data, store, evals, local_point)? } - "jolt.stage6.booleanity" => { + Stage6RelationKind::Stage6Booleanity => { expected_booleanity(program, store, evals, local_point)? } - "jolt.stage6.hamming_booleanity" => { + Stage6RelationKind::Stage6HammingBooleanity => { expected_hamming_booleanity(store, evals, local_point)? } - "jolt.stage6.ram_ra_virtual" => { + Stage6RelationKind::Stage6RamRaVirtual => { expected_ram_ra_virtual(store, evals, local_point)? } - "jolt.stage6.instruction_ra_virtual" => { + Stage6RelationKind::Stage6InstructionRaVirtual => { expected_instruction_ra_virtual(program, store, evals, local_point)? } - "jolt.stage6.inc_claim_reduction" => { + Stage6RelationKind::Stage6IncClaimReduction => { expected_inc_claim_reduction(store, evals, local_point)? } - _ => return Err(VerifyStage6Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; } diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 0f643fe509..bd460c36c7 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use super::common::{batch_claims, eval_by_name, find_batch, find_plan, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, reverse_slice}; +use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; use jolt_field::{Field, Fr, RingCore}; use jolt_poly::EqPolynomial; use jolt_sumcheck::SumcheckError; @@ -14,18 +14,23 @@ pub type Stage7Proof = super::common::StageProof; pub type Stage7OpeningInputValue = super::common::StageOpeningInputValue; pub use super::common::{ - FieldConstantPlan as Stage7FieldConstantPlan, FieldExprPlan as Stage7FieldExprPlan, + ClaimKind as Stage7ClaimKind, RelationKind as Stage7RelationKind, FieldConstantPlan as Stage7FieldConstantPlan, + FieldExprKind as Stage7FieldExprKind, + FieldExprPlan as Stage7FieldExprPlan, KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan, OpeningClaimEqualityPlan as Stage7OpeningClaimEqualityPlan, OpeningClaimPlan as Stage7OpeningClaimPlan, OpeningInputPlan as Stage7OpeningInputPlan, + OpeningEqualityMode as Stage7OpeningEqualityMode, PointConcatPlan as Stage7PointConcatPlan, PointSlicePlan as Stage7PointSlicePlan, - PointZeroPlan as Stage7PointZeroPlan, ProgramStepPlan as Stage7ProgramStepPlan, + PointZeroPlan as Stage7PointZeroPlan, ProgramStepKind as Stage7ProgramStepKind, + ProgramStepPlan as Stage7ProgramStepPlan, StageParams as Stage7Params, StageProgramPlan as Stage7CpuProgramPlan, SumcheckBatchPlan as Stage7SumcheckBatchPlan, SumcheckClaimPlan as Stage7SumcheckClaimPlan, SumcheckDriverPlan as Stage7SumcheckDriverPlan, SumcheckEvalPlan as Stage7SumcheckEvalPlan, SumcheckInstanceResultPlan as Stage7SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage7TranscriptAbsorbBytesPlan, + TranscriptSqueezeKind as Stage7TranscriptSqueezeKind, TranscriptSqueezePlan as Stage7TranscriptSqueezePlan, }; @@ -41,25 +46,20 @@ pub enum VerifyStage7Error { MissingValue { symbol: &'static str }, InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, - UnsupportedFieldExpr { symbol: &'static str, formula: &'static str }, - UnsupportedRelation { relation: &'static str }, + UnsupportedRelation { relation: Stage7RelationKind }, Sumcheck { driver: &'static str, error: SumcheckError }, } super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); -pub const STAGE7_PARAMS: Stage7Params = Stage7Params { - field: "bn254_fr", - pcs: "dory", - transcript: "blake2b_transcript", -}; +pub const STAGE7_PARAMS: Stage7Params = Stage7Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE7_PROGRAM_STEPS: &[Stage7ProgramStepPlan] = &[ - Stage7ProgramStepPlan { kind: "transcript_squeeze", symbol: "stage7.hamming_weight_claim_reduction.gamma" }, - Stage7ProgramStepPlan { kind: "sumcheck_driver", symbol: "stage7.sumcheck" }, + Stage7ProgramStepPlan { kind: Stage7ProgramStepKind::TranscriptSqueeze, symbol: "stage7.hamming_weight_claim_reduction.gamma" }, + Stage7ProgramStepPlan { kind: Stage7ProgramStepKind::SumcheckDriver, symbol: "stage7.sumcheck" }, ]; pub const STAGE7_TRANSCRIPT_SQUEEZES: &[Stage7TranscriptSqueezePlan] = &[ - Stage7TranscriptSqueezePlan { symbol: "stage7.hamming_weight_claim_reduction.gamma", label: "hamming_weight_claim_reduction_gamma", kind: "challenge_scalar", count: 1 }, + Stage7TranscriptSqueezePlan { symbol: "stage7.hamming_weight_claim_reduction.gamma", label: "hamming_weight_claim_reduction_gamma", kind: Stage7TranscriptSqueezeKind::ChallengeScalar, count: 1 }, ]; pub const STAGE7_TRANSCRIPT_ABSORB_BYTES: &[Stage7TranscriptAbsorbBytesPlan] = &[ @@ -67,85 +67,85 @@ pub const STAGE7_TRANSCRIPT_ABSORB_BYTES: &[Stage7TranscriptAbsorbBytesPlan] = & ]; pub const STAGE7_OPENING_INPUTS: &[Stage7OpeningInputPlan] = &[ - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.hamming_booleanity.HammingWeight", source_stage: "stage6", source_claim: "stage6.hamming_booleanity.opening.HammingWeight", oracle: "HammingWeight", domain: "jolt.trace_domain", point_arity: 16, claim_kind: "virtual" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_3", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_4", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_5", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_6", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_7", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_8", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_9", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_10", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_11", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_12", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_13", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_14", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_15", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_16", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_17", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_18", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_19", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_20", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_21", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_22", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_23", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_24", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_25", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_26", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_27", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_28", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_29", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_30", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_31", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_0", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_1", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_2", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_3", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_3", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.hamming_booleanity.HammingWeight", source_stage: "stage6", source_claim: "stage6.hamming_booleanity.opening.HammingWeight", oracle: "HammingWeight", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage7ClaimKind::Virtual }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_3", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_4", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_5", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_6", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_7", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_8", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_9", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_10", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_11", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_12", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_13", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_14", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_15", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_16", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_17", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_18", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_19", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_20", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_21", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_22", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_23", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_24", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_25", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_26", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_27", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_28", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_29", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_30", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.InstructionRa_31", source_stage: "stage6", source_claim: "stage6.booleanity.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", source_stage: "stage6", source_claim: "stage6.instruction_ra_virtual.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.BytecodeRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", source_stage: "stage6", source_claim: "stage6.bytecode_read_raf.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_0", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_0", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_1", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_1", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_2", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_2", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.booleanity.RamRa_3", source_stage: "stage6", source_claim: "stage6.booleanity.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, + Stage7OpeningInputPlan { symbol: "stage7.input.stage6.ram_ra_virtual.RamRa_3", source_stage: "stage6", source_claim: "stage6.ram_ra_virtual.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed }, ]; pub const STAGE7_FIELD_CONSTANTS: &[Stage7FieldConstantPlan] = &[ @@ -153,81 +153,77 @@ pub const STAGE7_FIELD_CONSTANTS: &[Stage7FieldConstantPlan] = &[ ]; macro_rules! stage7_field_expr { - ($symbol:literal, $formula:literal, $operands:literal) => { - Stage7FieldExprPlan { symbol: $symbol, kind: "op", formula: $formula, operands: $operands } + ($symbol:literal, $kind:expr, $operands:literal) => { + Stage7FieldExprPlan { symbol: $symbol, kind: $kind, operands: $operands } }; } #[rustfmt::skip] pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[ - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", "field.pow:1", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", "field.pow:2", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", "field.pow:3", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", "field.pow:4", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_1"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", "field.pow:5", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", "field.pow:6", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", "field.pow:7", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", "field.pow:8", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", "field.pow:9", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", "field.pow:10", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", "field.pow:11", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", "field.pow:12", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", "field.pow:13", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_4"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", "field.pow:14", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", "field.pow:15", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", "field.pow:16", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_5"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", "field.pow:17", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", "field.pow:18", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", "field.pow:19", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_6"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", "field.pow:20", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", "field.pow:21", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", "field.pow:22", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_7"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", "field.pow:23", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", "field.pow:24", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", "field.pow:25", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_8"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", "field.pow:26", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", "field.pow:27", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", "field.pow:28", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_9"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", "field.pow:29", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", "field.pow:30", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", "field.pow:31", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_10"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", "field.pow:32", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", "field.pow:33", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", "field.pow:34", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_11"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", "field.pow:35", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", "field.pow:36", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", "field.pow:37", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_12"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", "field.pow:38", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", "field.pow:39", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", "field.pow:40", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_13"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", "field.pow:41", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", "field.pow:42", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", "field.pow:43", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_14"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", "field.pow:44", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", "field.pow:45", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", "field.pow:46", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_15"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", "field.pow:47", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", "field.pow:48", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", "field.pow:49", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_16"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", "field.pow:50", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", "field.pow:51", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", "field.pow:52", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_17"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", "field.pow:53", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", "field.pow:54", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", "field.pow:55", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_18"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", "field.pow:56", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", "field.pow:57", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", "field.pow:58", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_19"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", "field.pow:59", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", "field.pow:60", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", "field.pow:61", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_20"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", "field.pow:62", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", "field.pow:63", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", "field.pow:64", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_21"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", "field.pow:65", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", "field.pow:66", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", "field.pow:67", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_22"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", "field.pow:68", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", "field.pow:69", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", "field.pow:70", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_23"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", "field.pow:71", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", "field.pow:72", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", "field.pow:73", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_24"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", "field.pow:74", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", "field.pow:75", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", "field.pow:76", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_25"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", "field.pow:77", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", "field.pow:78", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", "field.pow:79", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_26"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", "field.pow:80", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", "field.pow:81", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", "field.pow:82", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_27"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", "field.pow:83", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", "field.pow:84", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", "field.pow:85", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_28"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", "field.pow:86", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", "field.pow:87", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", "field.pow:88", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_29"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", "field.pow:89", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", "field.pow:90", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", "field.pow:91", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_30"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", "field.pow:92", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", "field.pow:93", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", "field.pow:94", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_31"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", "field.pow:95", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", "field.pow:96", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", "field.pow:97", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", "field.pow:98", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", "field.pow:99", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", "field.pow:100", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_1"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", "field.pow:101", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", "field.pow:102", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", "field.pow:103", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", "field.pow:104", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", "field.pow:105", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", "field.pow:106", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", "field.pow:107", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", "field.pow:108", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", "field.pow:109", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", "field.pow:110", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", "field.pow:111", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", "field.pow:112", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_2"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", "field.pow:113", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", "field.pow:114", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", "field.pow:115", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", "field.pow:116", "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term", "field.mul", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_3"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial0", "field.add", "stage7.field.one|stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial1", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial0|stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial2", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial1|stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial3", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial2|stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial4", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial3|stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial5", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial4|stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial6", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial5|stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial7", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial6|stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial8", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial7|stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial9", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial8|stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial10", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial9|stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial11", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial10|stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial12", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial11|stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial13", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial12|stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial14", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial13|stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial15", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial14|stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial16", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial15|stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial17", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial16|stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial18", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial17|stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial19", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial18|stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial20", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial19|stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial21", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial20|stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial22", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial21|stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial23", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial22|stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial24", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial23|stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial25", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial24|stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial26", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial25|stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial27", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial26|stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial28", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial27|stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial29", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial28|stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial30", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial29|stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial31", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial30|stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial32", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial31|stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial33", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial32|stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial34", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial33|stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial35", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial34|stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial36", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial35|stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial37", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial36|stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial38", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial37|stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial39", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial38|stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial40", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial39|stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial41", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial40|stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial42", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial41|stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial43", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial42|stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial44", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial43|stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial45", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial44|stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial46", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial45|stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial47", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial46|stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial48", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial47|stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial49", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial48|stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial50", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial49|stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial51", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial50|stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial52", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial51|stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial53", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial52|stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial54", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial53|stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial55", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial54|stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial56", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial55|stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial57", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial56|stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial58", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial57|stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial59", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial58|stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial60", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial59|stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial61", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial60|stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial62", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial61|stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial63", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial62|stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial64", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial63|stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial65", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial64|stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial66", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial65|stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial67", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial66|stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial68", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial67|stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial69", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial68|stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial70", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial69|stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial71", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial70|stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial72", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial71|stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial73", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial72|stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial74", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial73|stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial75", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial74|stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial76", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial75|stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial77", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial76|stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial78", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial77|stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial79", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial78|stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial80", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial79|stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial81", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial80|stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial82", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial81|stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial83", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial82|stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial84", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial83|stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial85", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial84|stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial86", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial85|stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial87", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial86|stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial88", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial87|stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial89", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial88|stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial90", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial89|stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial91", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial90|stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial92", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial91|stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial93", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial92|stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial94", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial93|stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial95", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial94|stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial96", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial95|stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial97", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial96|stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial98", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial97|stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial99", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial98|stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial100", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial99|stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial101", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial100|stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial102", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial101|stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial103", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial102|stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial104", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial103|stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial105", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial104|stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial106", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial105|stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial107", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial106|stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial108", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial107|stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial109", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial108|stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial110", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial109|stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial111", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial110|stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial112", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial111|stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial113", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial112|stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial114", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial113|stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial115", "field.add", "stage7.hamming_weight_claim_reduction.claim_expr.partial114|stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", Stage7FieldExprKind::Pow(1), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", Stage7FieldExprKind::Pow(2), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", Stage7FieldExprKind::Pow(3), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", Stage7FieldExprKind::Pow(4), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_1"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", Stage7FieldExprKind::Pow(5), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", Stage7FieldExprKind::Pow(6), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", Stage7FieldExprKind::Pow(7), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", Stage7FieldExprKind::Pow(8), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", Stage7FieldExprKind::Pow(9), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", Stage7FieldExprKind::Pow(10), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", Stage7FieldExprKind::Pow(11), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", Stage7FieldExprKind::Pow(12), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow|stage7.field.one"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", Stage7FieldExprKind::Pow(13), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_4"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", Stage7FieldExprKind::Pow(14), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", Stage7FieldExprKind::Pow(15), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", Stage7FieldExprKind::Pow(16), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_5"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", Stage7FieldExprKind::Pow(17), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", Stage7FieldExprKind::Pow(18), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", Stage7FieldExprKind::Pow(19), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_6"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", Stage7FieldExprKind::Pow(20), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", Stage7FieldExprKind::Pow(21), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", Stage7FieldExprKind::Pow(22), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_7"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", Stage7FieldExprKind::Pow(23), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", Stage7FieldExprKind::Pow(24), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow|stage7.field.one"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", Stage7FieldExprKind::Pow(25), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_8"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", Stage7FieldExprKind::Pow(26), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", Stage7FieldExprKind::Pow(27), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", Stage7FieldExprKind::Pow(28), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_9"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", Stage7FieldExprKind::Pow(29), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", Stage7FieldExprKind::Pow(30), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", Stage7FieldExprKind::Pow(31), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_10"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", Stage7FieldExprKind::Pow(32), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", Stage7FieldExprKind::Pow(33), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", Stage7FieldExprKind::Pow(34), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_11"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", Stage7FieldExprKind::Pow(35), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", Stage7FieldExprKind::Pow(36), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow|stage7.field.one"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", Stage7FieldExprKind::Pow(37), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_12"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", Stage7FieldExprKind::Pow(38), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", Stage7FieldExprKind::Pow(39), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", Stage7FieldExprKind::Pow(40), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_13"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", Stage7FieldExprKind::Pow(41), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", Stage7FieldExprKind::Pow(42), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", Stage7FieldExprKind::Pow(43), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_14"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", Stage7FieldExprKind::Pow(44), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", Stage7FieldExprKind::Pow(45), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", Stage7FieldExprKind::Pow(46), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_15"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", Stage7FieldExprKind::Pow(47), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", Stage7FieldExprKind::Pow(48), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow|stage7.field.one"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", Stage7FieldExprKind::Pow(49), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_16"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", Stage7FieldExprKind::Pow(50), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", Stage7FieldExprKind::Pow(51), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", Stage7FieldExprKind::Pow(52), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_17"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", Stage7FieldExprKind::Pow(53), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", Stage7FieldExprKind::Pow(54), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", Stage7FieldExprKind::Pow(55), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_18"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", Stage7FieldExprKind::Pow(56), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", Stage7FieldExprKind::Pow(57), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", Stage7FieldExprKind::Pow(58), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_19"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", Stage7FieldExprKind::Pow(59), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", Stage7FieldExprKind::Pow(60), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow|stage7.field.one"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", Stage7FieldExprKind::Pow(61), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_20"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", Stage7FieldExprKind::Pow(62), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", Stage7FieldExprKind::Pow(63), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", Stage7FieldExprKind::Pow(64), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_21"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", Stage7FieldExprKind::Pow(65), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", Stage7FieldExprKind::Pow(66), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", Stage7FieldExprKind::Pow(67), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_22"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", Stage7FieldExprKind::Pow(68), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", Stage7FieldExprKind::Pow(69), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", Stage7FieldExprKind::Pow(70), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_23"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", Stage7FieldExprKind::Pow(71), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", Stage7FieldExprKind::Pow(72), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow|stage7.field.one"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", Stage7FieldExprKind::Pow(73), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_24"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", Stage7FieldExprKind::Pow(74), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", Stage7FieldExprKind::Pow(75), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", Stage7FieldExprKind::Pow(76), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_25"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", Stage7FieldExprKind::Pow(77), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", Stage7FieldExprKind::Pow(78), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", Stage7FieldExprKind::Pow(79), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_26"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", Stage7FieldExprKind::Pow(80), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", Stage7FieldExprKind::Pow(81), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", Stage7FieldExprKind::Pow(82), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_27"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", Stage7FieldExprKind::Pow(83), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", Stage7FieldExprKind::Pow(84), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow|stage7.field.one"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", Stage7FieldExprKind::Pow(85), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_28"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", Stage7FieldExprKind::Pow(86), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", Stage7FieldExprKind::Pow(87), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", Stage7FieldExprKind::Pow(88), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_29"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", Stage7FieldExprKind::Pow(89), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", Stage7FieldExprKind::Pow(90), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", Stage7FieldExprKind::Pow(91), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_30"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", Stage7FieldExprKind::Pow(92), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", Stage7FieldExprKind::Pow(93), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", Stage7FieldExprKind::Pow(94), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_31"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", Stage7FieldExprKind::Pow(95), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", Stage7FieldExprKind::Pow(96), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow|stage7.field.one"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", Stage7FieldExprKind::Pow(97), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", Stage7FieldExprKind::Pow(98), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", Stage7FieldExprKind::Pow(99), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", Stage7FieldExprKind::Pow(100), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_1"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", Stage7FieldExprKind::Pow(101), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", Stage7FieldExprKind::Pow(102), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", Stage7FieldExprKind::Pow(103), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", Stage7FieldExprKind::Pow(104), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", Stage7FieldExprKind::Pow(105), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", Stage7FieldExprKind::Pow(106), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", Stage7FieldExprKind::Pow(107), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", Stage7FieldExprKind::Pow(108), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", Stage7FieldExprKind::Pow(109), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", Stage7FieldExprKind::Pow(110), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", Stage7FieldExprKind::Pow(111), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", Stage7FieldExprKind::Pow(112), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_2"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", Stage7FieldExprKind::Pow(113), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", Stage7FieldExprKind::Pow(114), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", Stage7FieldExprKind::Pow(115), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", Stage7FieldExprKind::Pow(116), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_3"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial0", Stage7FieldExprKind::Add, "stage7.field.one|stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial1", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial0|stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial2", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial1|stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial3", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial2|stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial4", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial3|stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial5", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial4|stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial6", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial5|stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial7", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial6|stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial8", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial7|stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial9", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial8|stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial10", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial9|stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial11", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial10|stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial12", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial11|stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial13", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial12|stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial14", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial13|stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial15", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial14|stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial16", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial15|stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial17", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial16|stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial18", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial17|stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial19", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial18|stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial20", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial19|stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial21", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial20|stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial22", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial21|stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial23", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial22|stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial24", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial23|stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial25", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial24|stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial26", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial25|stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial27", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial26|stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial28", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial27|stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial29", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial28|stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial30", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial29|stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial31", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial30|stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial32", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial31|stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial33", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial32|stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial34", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial33|stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial35", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial34|stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial36", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial35|stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial37", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial36|stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial38", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial37|stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial39", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial38|stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial40", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial39|stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial41", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial40|stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial42", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial41|stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial43", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial42|stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial44", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial43|stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial45", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial44|stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial46", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial45|stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial47", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial46|stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial48", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial47|stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial49", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial48|stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial50", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial49|stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial51", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial50|stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial52", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial51|stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial53", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial52|stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial54", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial53|stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial55", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial54|stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial56", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial55|stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial57", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial56|stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial58", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial57|stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial59", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial58|stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial60", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial59|stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial61", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial60|stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial62", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial61|stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial63", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial62|stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial64", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial63|stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial65", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial64|stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial66", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial65|stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial67", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial66|stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial68", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial67|stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial69", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial68|stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial70", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial69|stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial71", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial70|stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial72", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial71|stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial73", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial72|stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial74", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial73|stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial75", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial74|stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial76", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial75|stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial77", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial76|stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial78", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial77|stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial79", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial78|stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial80", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial79|stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial81", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial80|stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial82", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial81|stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial83", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial82|stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial84", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial83|stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial85", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial84|stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial86", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial85|stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial87", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial86|stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial88", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial87|stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial89", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial88|stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial90", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial89|stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial91", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial90|stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial92", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial91|stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial93", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial92|stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial94", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial93|stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial95", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial94|stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial96", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial95|stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial97", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial96|stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial98", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial97|stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial99", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial98|stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial100", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial99|stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial101", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial100|stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial102", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial101|stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial103", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial102|stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial104", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial103|stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial105", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial104|stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial106", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial105|stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial107", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial106|stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial108", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial107|stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial109", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial108|stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial110", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial109|stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial111", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial110|stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial111|stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial112|stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial113|stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial114|stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"), ]; pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ ]; pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[ - Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some("jolt.stage7.hamming_weight_claim_reduction"), claim_value: "stage7.hamming_weight_claim_reduction.claim_expr.partial115", input_openings: "stage7.input.stage6.hamming_booleanity.HammingWeight|stage7.input.stage6.booleanity.InstructionRa_0|stage7.input.stage6.instruction_ra_virtual.InstructionRa_0|stage7.input.stage6.booleanity.InstructionRa_1|stage7.input.stage6.instruction_ra_virtual.InstructionRa_1|stage7.input.stage6.booleanity.InstructionRa_2|stage7.input.stage6.instruction_ra_virtual.InstructionRa_2|stage7.input.stage6.booleanity.InstructionRa_3|stage7.input.stage6.instruction_ra_virtual.InstructionRa_3|stage7.input.stage6.booleanity.InstructionRa_4|stage7.input.stage6.instruction_ra_virtual.InstructionRa_4|stage7.input.stage6.booleanity.InstructionRa_5|stage7.input.stage6.instruction_ra_virtual.InstructionRa_5|stage7.input.stage6.booleanity.InstructionRa_6|stage7.input.stage6.instruction_ra_virtual.InstructionRa_6|stage7.input.stage6.booleanity.InstructionRa_7|stage7.input.stage6.instruction_ra_virtual.InstructionRa_7|stage7.input.stage6.booleanity.InstructionRa_8|stage7.input.stage6.instruction_ra_virtual.InstructionRa_8|stage7.input.stage6.booleanity.InstructionRa_9|stage7.input.stage6.instruction_ra_virtual.InstructionRa_9|stage7.input.stage6.booleanity.InstructionRa_10|stage7.input.stage6.instruction_ra_virtual.InstructionRa_10|stage7.input.stage6.booleanity.InstructionRa_11|stage7.input.stage6.instruction_ra_virtual.InstructionRa_11|stage7.input.stage6.booleanity.InstructionRa_12|stage7.input.stage6.instruction_ra_virtual.InstructionRa_12|stage7.input.stage6.booleanity.InstructionRa_13|stage7.input.stage6.instruction_ra_virtual.InstructionRa_13|stage7.input.stage6.booleanity.InstructionRa_14|stage7.input.stage6.instruction_ra_virtual.InstructionRa_14|stage7.input.stage6.booleanity.InstructionRa_15|stage7.input.stage6.instruction_ra_virtual.InstructionRa_15|stage7.input.stage6.booleanity.InstructionRa_16|stage7.input.stage6.instruction_ra_virtual.InstructionRa_16|stage7.input.stage6.booleanity.InstructionRa_17|stage7.input.stage6.instruction_ra_virtual.InstructionRa_17|stage7.input.stage6.booleanity.InstructionRa_18|stage7.input.stage6.instruction_ra_virtual.InstructionRa_18|stage7.input.stage6.booleanity.InstructionRa_19|stage7.input.stage6.instruction_ra_virtual.InstructionRa_19|stage7.input.stage6.booleanity.InstructionRa_20|stage7.input.stage6.instruction_ra_virtual.InstructionRa_20|stage7.input.stage6.booleanity.InstructionRa_21|stage7.input.stage6.instruction_ra_virtual.InstructionRa_21|stage7.input.stage6.booleanity.InstructionRa_22|stage7.input.stage6.instruction_ra_virtual.InstructionRa_22|stage7.input.stage6.booleanity.InstructionRa_23|stage7.input.stage6.instruction_ra_virtual.InstructionRa_23|stage7.input.stage6.booleanity.InstructionRa_24|stage7.input.stage6.instruction_ra_virtual.InstructionRa_24|stage7.input.stage6.booleanity.InstructionRa_25|stage7.input.stage6.instruction_ra_virtual.InstructionRa_25|stage7.input.stage6.booleanity.InstructionRa_26|stage7.input.stage6.instruction_ra_virtual.InstructionRa_26|stage7.input.stage6.booleanity.InstructionRa_27|stage7.input.stage6.instruction_ra_virtual.InstructionRa_27|stage7.input.stage6.booleanity.InstructionRa_28|stage7.input.stage6.instruction_ra_virtual.InstructionRa_28|stage7.input.stage6.booleanity.InstructionRa_29|stage7.input.stage6.instruction_ra_virtual.InstructionRa_29|stage7.input.stage6.booleanity.InstructionRa_30|stage7.input.stage6.instruction_ra_virtual.InstructionRa_30|stage7.input.stage6.booleanity.InstructionRa_31|stage7.input.stage6.instruction_ra_virtual.InstructionRa_31|stage7.input.stage6.booleanity.BytecodeRa_0|stage7.input.stage6.bytecode_read_raf.BytecodeRa_0|stage7.input.stage6.booleanity.BytecodeRa_1|stage7.input.stage6.bytecode_read_raf.BytecodeRa_1|stage7.input.stage6.booleanity.BytecodeRa_2|stage7.input.stage6.bytecode_read_raf.BytecodeRa_2|stage7.input.stage6.booleanity.RamRa_0|stage7.input.stage6.ram_ra_virtual.RamRa_0|stage7.input.stage6.booleanity.RamRa_1|stage7.input.stage6.ram_ra_virtual.RamRa_1|stage7.input.stage6.booleanity.RamRa_2|stage7.input.stage6.ram_ra_virtual.RamRa_2|stage7.input.stage6.booleanity.RamRa_3|stage7.input.stage6.ram_ra_virtual.RamRa_3" }, -]; -pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[ - 4, + Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some(Stage7RelationKind::Stage7HammingWeightClaimReduction), claim_value: "stage7.hamming_weight_claim_reduction.claim_expr.partial115", input_openings: "stage7.input.stage6.hamming_booleanity.HammingWeight|stage7.input.stage6.booleanity.InstructionRa_0|stage7.input.stage6.instruction_ra_virtual.InstructionRa_0|stage7.input.stage6.booleanity.InstructionRa_1|stage7.input.stage6.instruction_ra_virtual.InstructionRa_1|stage7.input.stage6.booleanity.InstructionRa_2|stage7.input.stage6.instruction_ra_virtual.InstructionRa_2|stage7.input.stage6.booleanity.InstructionRa_3|stage7.input.stage6.instruction_ra_virtual.InstructionRa_3|stage7.input.stage6.booleanity.InstructionRa_4|stage7.input.stage6.instruction_ra_virtual.InstructionRa_4|stage7.input.stage6.booleanity.InstructionRa_5|stage7.input.stage6.instruction_ra_virtual.InstructionRa_5|stage7.input.stage6.booleanity.InstructionRa_6|stage7.input.stage6.instruction_ra_virtual.InstructionRa_6|stage7.input.stage6.booleanity.InstructionRa_7|stage7.input.stage6.instruction_ra_virtual.InstructionRa_7|stage7.input.stage6.booleanity.InstructionRa_8|stage7.input.stage6.instruction_ra_virtual.InstructionRa_8|stage7.input.stage6.booleanity.InstructionRa_9|stage7.input.stage6.instruction_ra_virtual.InstructionRa_9|stage7.input.stage6.booleanity.InstructionRa_10|stage7.input.stage6.instruction_ra_virtual.InstructionRa_10|stage7.input.stage6.booleanity.InstructionRa_11|stage7.input.stage6.instruction_ra_virtual.InstructionRa_11|stage7.input.stage6.booleanity.InstructionRa_12|stage7.input.stage6.instruction_ra_virtual.InstructionRa_12|stage7.input.stage6.booleanity.InstructionRa_13|stage7.input.stage6.instruction_ra_virtual.InstructionRa_13|stage7.input.stage6.booleanity.InstructionRa_14|stage7.input.stage6.instruction_ra_virtual.InstructionRa_14|stage7.input.stage6.booleanity.InstructionRa_15|stage7.input.stage6.instruction_ra_virtual.InstructionRa_15|stage7.input.stage6.booleanity.InstructionRa_16|stage7.input.stage6.instruction_ra_virtual.InstructionRa_16|stage7.input.stage6.booleanity.InstructionRa_17|stage7.input.stage6.instruction_ra_virtual.InstructionRa_17|stage7.input.stage6.booleanity.InstructionRa_18|stage7.input.stage6.instruction_ra_virtual.InstructionRa_18|stage7.input.stage6.booleanity.InstructionRa_19|stage7.input.stage6.instruction_ra_virtual.InstructionRa_19|stage7.input.stage6.booleanity.InstructionRa_20|stage7.input.stage6.instruction_ra_virtual.InstructionRa_20|stage7.input.stage6.booleanity.InstructionRa_21|stage7.input.stage6.instruction_ra_virtual.InstructionRa_21|stage7.input.stage6.booleanity.InstructionRa_22|stage7.input.stage6.instruction_ra_virtual.InstructionRa_22|stage7.input.stage6.booleanity.InstructionRa_23|stage7.input.stage6.instruction_ra_virtual.InstructionRa_23|stage7.input.stage6.booleanity.InstructionRa_24|stage7.input.stage6.instruction_ra_virtual.InstructionRa_24|stage7.input.stage6.booleanity.InstructionRa_25|stage7.input.stage6.instruction_ra_virtual.InstructionRa_25|stage7.input.stage6.booleanity.InstructionRa_26|stage7.input.stage6.instruction_ra_virtual.InstructionRa_26|stage7.input.stage6.booleanity.InstructionRa_27|stage7.input.stage6.instruction_ra_virtual.InstructionRa_27|stage7.input.stage6.booleanity.InstructionRa_28|stage7.input.stage6.instruction_ra_virtual.InstructionRa_28|stage7.input.stage6.booleanity.InstructionRa_29|stage7.input.stage6.instruction_ra_virtual.InstructionRa_29|stage7.input.stage6.booleanity.InstructionRa_30|stage7.input.stage6.instruction_ra_virtual.InstructionRa_30|stage7.input.stage6.booleanity.InstructionRa_31|stage7.input.stage6.instruction_ra_virtual.InstructionRa_31|stage7.input.stage6.booleanity.BytecodeRa_0|stage7.input.stage6.bytecode_read_raf.BytecodeRa_0|stage7.input.stage6.booleanity.BytecodeRa_1|stage7.input.stage6.bytecode_read_raf.BytecodeRa_1|stage7.input.stage6.booleanity.BytecodeRa_2|stage7.input.stage6.bytecode_read_raf.BytecodeRa_2|stage7.input.stage6.booleanity.RamRa_0|stage7.input.stage6.ram_ra_virtual.RamRa_0|stage7.input.stage6.booleanity.RamRa_1|stage7.input.stage6.ram_ra_virtual.RamRa_1|stage7.input.stage6.booleanity.RamRa_2|stage7.input.stage6.ram_ra_virtual.RamRa_2|stage7.input.stage6.booleanity.RamRa_3|stage7.input.stage6.ram_ra_virtual.RamRa_3" }, ]; +pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[ Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, ordered_claims: "stage7.hamming_weight_claim_reduction.input", claim_operands: "stage7.hamming_weight_claim_reduction.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; -pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[ - 4, -]; +pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_DRIVERS: &[Stage7SumcheckDriverPlan] = &[ - Stage7SumcheckDriverPlan { symbol: "stage7.sumcheck", stage: "stage7", proof_slot: "stage7.sumcheck", kernel: None, relation: Some("jolt.stage7.batched"), batch: "stage7.batch", policy: "jolt_core_stage7_aligned", round_schedule: STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 4, degree: 2 }, + Stage7SumcheckDriverPlan { symbol: "stage7.sumcheck", stage: "stage7", proof_slot: "stage7.sumcheck", kernel: None, relation: Some(Stage7RelationKind::Stage7Batched), batch: "stage7.batch", policy: "jolt_core_stage7_aligned", round_schedule: STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 4, degree: 2 }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ - Stage7SumcheckInstanceResultPlan { symbol: "stage7.hamming_weight_claim_reduction.instance", source: "stage7.sumcheck", claim: "stage7.hamming_weight_claim_reduction.input", relation: "jolt.stage7.hamming_weight_claim_reduction", index: 0, point_arity: 4, num_rounds: 4, round_offset: 0, point_order: "reverse", degree: 2 }, + Stage7SumcheckInstanceResultPlan { symbol: "stage7.hamming_weight_claim_reduction.instance", source: "stage7.sumcheck", claim: "stage7.hamming_weight_claim_reduction.input", relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, index: 0, point_arity: 4, num_rounds: 4, round_offset: 0, point_order: "reverse", degree: 2 }, ]; macro_rules! stage7_sumcheck_eval { @@ -262,45 +258,45 @@ pub const STAGE7_POINT_CONCATS: &[Stage7PointConcatPlan] = &[ Stage7PointConcatPlan { symbol: "stage7.hamming_weight_claim_reduction.point", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage7.hamming_weight_claim_reduction.instance|stage7.hamming_weight_claim_reduction.point.cycle" }, ]; pub const STAGE7_OPENING_CLAIMS: &[Stage7OpeningClaimPlan] = &[ - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_0" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_1" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_2" }, - Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_3" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_0" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_1" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_2" }, + Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.RamRa_3" }, ]; pub const STAGE7_OPENING_EQUALITIES: &[Stage7OpeningClaimEqualityPlan] = &[ @@ -366,14 +362,14 @@ where let mut artifacts = Stage7ExecutionArtifacts::default(); for step in program.steps { match step.kind { - "transcript_squeeze" => { + Stage7ProgramStepKind::TranscriptSqueeze => { let squeeze = find_plan(program.transcript_squeezes, step.symbol).ok_or(VerifyStage7Error::MissingValue { symbol: step.symbol, })?; verify_stage7_squeeze(program, squeeze, &mut store, transcript, &mut artifacts)?; } - "transcript_absorb_bytes" => { + Stage7ProgramStepKind::TranscriptAbsorbBytes => { let absorb = find_plan(program.transcript_absorb_bytes, step.symbol).ok_or( VerifyStage7Error::MissingValue { symbol: step.symbol, @@ -381,7 +377,7 @@ where )?; absorb_stage7_bytes(absorb, transcript); } - "sumcheck_driver" => { + Stage7ProgramStepKind::SumcheckDriver => { let driver = find_plan(program.drivers, step.symbol).ok_or(VerifyStage7Error::MissingProof { driver: step.symbol, @@ -395,12 +391,6 @@ where &mut artifacts, )?; } - _ => { - return Err(VerifyStage7Error::InvalidProof { - driver: step.symbol, - reason: "unsupported stage7 program step", - }); - } } } artifacts @@ -469,12 +459,17 @@ where .ok_or(VerifyStage7Error::MissingProof { driver: driver.symbol, })?; - let relation = driver.relation.unwrap_or(""); + let Some(relation) = driver.relation else { + return Err(VerifyStage7Error::InvalidProof { + driver: driver.symbol, + reason: "missing driver relation", + }); + }; let output = match relation { - "jolt.stage7.batched" => { + Stage7RelationKind::Stage7Batched => { verify_batched_stage7(program, driver, proof, store, transcript)? } - _ => return Err(VerifyStage7Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }), }; artifacts.sumchecks.push(output); Ok(()) @@ -522,9 +517,7 @@ fn observe_stage7_sumcheck_output( match instance.point_order { "as_is" => {} "reverse" => point.reverse(), - "bytecode_read_raf" => point = normalize_bytecode_read_raf_point(&point, stage7_trace_rounds(program)?, "stage7.bytecode_read_raf.point")?, "stage7_booleanity" => {} - "instruction_read_raf" => point = normalize_instruction_read_raf_point(&point, "stage7.instruction_read_raf.point")?, _ => { return Err(VerifyStage7Error::InvalidProof { driver: output.driver, @@ -587,12 +580,17 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let relation = claim.relation.unwrap_or(""); + let Some(relation) = claim.relation else { + return Err(VerifyStage7Error::InvalidProof { + driver: driver.symbol, + reason: "missing claim relation", + }); + }; let value = match relation { - "jolt.stage7.hamming_weight_claim_reduction" => { + Stage7RelationKind::Stage7HammingWeightClaimReduction => { expected_hamming_weight_claim_reduction(program, driver, store, evals, local_point)? } - _ => return Err(VerifyStage7Error::UnsupportedRelation { relation }), + relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; } @@ -667,16 +665,3 @@ fn stage7_virtualization_point<'a>( actual: point.len(), }) } - -fn stage7_trace_rounds( - program: &'static Stage7VerifierProgramPlan, -) -> Result { - program - .instance_results - .iter() - .find(|instance| instance.relation == "jolt.stage7.hamming_booleanity") - .map(|instance| instance.num_rounds) - .ok_or(VerifyStage7Error::MissingValue { - symbol: "stage7.hamming_booleanity.instance", - }) -} diff --git a/crates/jolt-verifier/src/stages/stage8.rs b/crates/jolt-verifier/src/stages/stage8.rs index 6d245c8ba9..4e846856e8 100644 --- a/crates/jolt-verifier/src/stages/stage8.rs +++ b/crates/jolt-verifier/src/stages/stage8.rs @@ -1,53 +1,57 @@ #![allow(clippy::too_many_lines)] -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage8Params { - pub field: &'static str, - pub pcs: &'static str, - pub transcript: &'static str, -} +pub use super::common::{ClaimKind as Stage8ClaimKind, PcsProofMode as Stage8PcsProofMode, SourceStage as Stage8SourceStage, StageParams as Stage8Params, TypedPlanSymbol}; + +pub enum Stage8OpeningInputTag {} +pub type Stage8OpeningInputSymbol = TypedPlanSymbol; +pub enum Stage8OpeningClaimTag {} +pub type Stage8OpeningClaimSymbol = TypedPlanSymbol; +pub enum Stage8OpeningBatchTag {} +pub type Stage8OpeningBatchSymbol = TypedPlanSymbol; +pub enum Stage8SourceClaimTag {} +pub type Stage8SourceClaim = TypedPlanSymbol; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8OpeningInputPlan { - pub symbol: &'static str, - pub source_stage: &'static str, - pub source_claim: &'static str, + pub symbol: Stage8OpeningInputSymbol, + pub source_stage: Stage8SourceStage, + pub source_claim: Stage8SourceClaim, pub oracle: &'static str, pub domain: &'static str, pub point_arity: usize, - pub claim_kind: &'static str, + pub claim_kind: Stage8ClaimKind, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8OpeningClaimPlan { - pub symbol: &'static str, + pub symbol: Stage8OpeningClaimSymbol, pub oracle: &'static str, pub family: &'static str, pub domain: &'static str, pub point_arity: usize, - pub point_source: &'static str, - pub eval_source: &'static str, - pub source_stage: &'static str, - pub source_claim: &'static str, + pub point_source: Stage8OpeningInputSymbol, + pub eval_source: Stage8OpeningInputSymbol, + pub source_stage: Stage8SourceStage, + pub source_claim: Stage8SourceClaim, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8OpeningBatchPlan { - pub symbol: &'static str, + pub symbol: Stage8OpeningBatchSymbol, pub proof_slot: &'static str, pub policy: &'static str, pub count: usize, - pub ordered_claims: &'static [&'static str], + pub ordered_claims: &'static [Stage8OpeningClaimPlan], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8PcsProofPlan { pub symbol: &'static str, - pub mode: &'static str, + pub mode: Stage8PcsProofMode, pub pcs: &'static str, pub proof_slot: &'static str, pub transcript_label: &'static str, - pub batch: &'static str, + pub batch: Stage8OpeningBatchSymbol, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -62,112 +66,294 @@ pub struct Stage8EvaluationProgramPlan { pub pcs_proof: Stage8PcsProofPlan, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage8EvaluationClaim { + pub oracle: &'static str, + pub source_stage: Stage8SourceStage, + pub value: F, +} + +pub fn reverse_point(point: &[F]) -> Vec { + point.iter().rev().copied().collect() +} + +pub fn append_rlc_claims(transcript: &mut T, claims: &[Stage8EvaluationClaim]) +where + F: jolt_field::Field + jolt_transcript::AppendToTranscript, + T: jolt_transcript::Transcript, +{ + transcript.append(&jolt_transcript::LabelWithCount( + b"rlc_claims", + claims.len() as u64, + )); + for claim in claims { + jolt_transcript::AppendToTranscript::append_to_transcript(&claim.value, transcript); + } +} + +pub fn gamma_powers(transcript: &mut T, count: usize) -> Vec +where + F: jolt_field::Field, + T: jolt_transcript::Transcript, +{ + let gamma = transcript.challenge(); + let mut powers = Vec::with_capacity(count); + let mut power = F::from_u64(1); + for _ in 0..count { + powers.push(power); + power *= gamma; + } + powers +} + +pub trait Stage8NamedEvalView { + fn name(&self) -> &'static str; + fn value(&self) -> F; +} + +pub trait Stage8SumcheckOutputView { + type Eval: Stage8NamedEvalView; + + fn point(&self) -> &[F]; + fn evals(&self) -> &[Self::Eval]; +} + +pub fn stage7_claim_values( + program: &'static Stage8EvaluationProgramPlan, + outputs: &[O], +) -> Option<(Vec, std::collections::BTreeMap)> +where + F: Copy, + O: Stage8SumcheckOutputView, +{ + let stage7_plans = program + .opening_claims + .iter() + .filter(|plan| plan.source_stage == Stage8SourceStage::Stage7) + .collect::>(); + for output in outputs { + let mut values = std::collections::BTreeMap::new(); + for plan in &stage7_plans { + if let Some(eval) = output + .evals() + .iter() + .find(|eval| eval.name() == plan.source_claim.as_str()) + { + let _ = values.insert(plan.source_claim, eval.value()); + } + } + if values.len() == stage7_plans.len() { + return Some((output.point().to_vec(), values)); + } + } + None +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage8EvaluationClaimError { + pub stage: &'static str, + pub eval: &'static str, +} + +pub fn evaluation_claims( + program: &'static Stage8EvaluationProgramPlan, + stage6_outputs: &[O], + stage7_values: &std::collections::BTreeMap, + lagrange_factor: F, +) -> Result>, Stage8EvaluationClaimError> +where + F: Copy + std::ops::Mul, + O: Stage8SumcheckOutputView, +{ + let mut claims = Vec::with_capacity(program.opening_claims.len()); + for plan in program.opening_claims { + let value = match plan.source_stage { + Stage8SourceStage::Stage6 => { + stage_eval(stage6_outputs, plan.source_stage.as_str(), plan.source_claim)? + * lagrange_factor + } + Stage8SourceStage::Stage7 => *stage7_values.get(&plan.source_claim).ok_or( + Stage8EvaluationClaimError { + stage: plan.source_stage.as_str(), + eval: plan.source_claim.as_str(), + }, + )?, + }; + claims.push(Stage8EvaluationClaim { + oracle: plan.oracle, + source_stage: plan.source_stage, + value, + }); + } + Ok(claims) +} + +fn stage_eval( + outputs: &[O], + stage: &'static str, + eval_name: Stage8SourceClaim, +) -> Result +where + F: Copy, + O: Stage8SumcheckOutputView, +{ + for output in outputs { + let eval = output + .evals() + .iter() + .find(|eval| eval.name() == eval_name.as_str()); + if let Some(eval) = eval { return Ok(eval.value()); } + } + Err(Stage8EvaluationClaimError { + stage, + eval: eval_name.as_str(), + }) +} + +pub trait Stage8OpeningInputView { + fn symbol(&self) -> &'static str; + fn point(&self) -> &[F]; +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage8EvaluationOpeningPointError { + MissingStage7EvaluationPoint, + InvalidPointLength { + artifact: &'static str, + expected: usize, + actual: usize, + }, +} + +pub fn stage7_evaluation_opening_point( + program: &'static Stage8EvaluationProgramPlan, + address_point: &[F], + stage7_openings: &[I], +) -> Result<(Vec, usize), Stage8EvaluationOpeningPointError> +where + F: Copy, + I: Stage8OpeningInputView, +{ + let cycle_source_symbol = program.evaluation_point_source.source_claim; + let cycle_source = stage7_openings + .iter() + .find(|input| input.symbol() == cycle_source_symbol.as_str()) + .ok_or(Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint)?; + let cycle_source_point = cycle_source.point(); + if cycle_source_point.len() < address_point.len() { + return Err(Stage8EvaluationOpeningPointError::InvalidPointLength { + artifact: cycle_source_symbol.as_str(), + expected: address_point.len(), + actual: cycle_source_point.len(), + }); + } + let cycle_len = cycle_source_point.len() - address_point.len(); + let mut point = Vec::with_capacity(cycle_source_point.len()); + point.extend_from_slice(address_point); + point.extend_from_slice(&cycle_source_point[address_point.len()..]); + Ok((point, cycle_len)) +} + pub const STAGE8_PARAMS: Stage8Params = Stage8Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; -pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = Stage8OpeningInputPlan { symbol: "stage8.evaluation.point_source", source_stage: "stage7", source_claim: "stage7.input.stage6.booleanity.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }; +pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.evaluation.point_source"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.input.stage6.booleanity.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }; +#[rustfmt::skip] pub const STAGE8_OPENING_INPUTS: &[Stage8OpeningInputPlan] = &[ - Stage8OpeningInputPlan { symbol: "stage8.evaluation.point_source", source_stage: "stage7", source_claim: "stage7.input.stage6.booleanity.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage6.RamInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RamInc", oracle: "RamInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage6.RdInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RdInc", oracle: "RdInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_4", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_5", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_6", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_7", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_8", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_9", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_10", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_11", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_12", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_13", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_14", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_15", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_16", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_17", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_18", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_19", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_20", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_21", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_22", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_23", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_24", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_25", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_26", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_27", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_28", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_29", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_30", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.InstructionRa_31", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.BytecodeRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_0", oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_1", oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_2", oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, - Stage8OpeningInputPlan { symbol: "stage8.input.stage7.RamRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_3", oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed" }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.evaluation.point_source"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.input.stage6.booleanity.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RamInc"), oracle: "RamInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RdInc"), oracle: "RdInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1"), oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2"), oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3"), oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4"), oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5"), oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6"), oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7"), oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8"), oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9"), oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10"), oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11"), oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12"), oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13"), oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14"), oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15"), oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16"), oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17"), oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18"), oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19"), oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20"), oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21"), oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22"), oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23"), oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24"), oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25"), oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26"), oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27"), oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28"), oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29"), oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30"), oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31"), oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0"), oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1"), oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2"), oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_0"), oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_1"), oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_2"), oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_3"), oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, ]; +#[rustfmt::skip] pub const STAGE8_OPENING_CLAIMS: &[Stage8OpeningClaimPlan] = &[ - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamInc", oracle: "RamInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage6.RamInc", eval_source: "stage8.input.stage6.RamInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RamInc" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RdInc", oracle: "RdInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage6.RdInc", eval_source: "stage8.input.stage6.RdInc", source_stage: "stage6", source_claim: "stage6.inc_claim_reduction.eval.RdInc" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_0", oracle: "InstructionRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_0", eval_source: "stage8.input.stage7.InstructionRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_1", oracle: "InstructionRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_1", eval_source: "stage8.input.stage7.InstructionRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_2", oracle: "InstructionRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_2", eval_source: "stage8.input.stage7.InstructionRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_3", oracle: "InstructionRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_3", eval_source: "stage8.input.stage7.InstructionRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_4", oracle: "InstructionRa_4", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_4", eval_source: "stage8.input.stage7.InstructionRa_4", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_5", oracle: "InstructionRa_5", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_5", eval_source: "stage8.input.stage7.InstructionRa_5", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_6", oracle: "InstructionRa_6", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_6", eval_source: "stage8.input.stage7.InstructionRa_6", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_7", oracle: "InstructionRa_7", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_7", eval_source: "stage8.input.stage7.InstructionRa_7", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_8", oracle: "InstructionRa_8", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_8", eval_source: "stage8.input.stage7.InstructionRa_8", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_9", oracle: "InstructionRa_9", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_9", eval_source: "stage8.input.stage7.InstructionRa_9", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_10", oracle: "InstructionRa_10", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_10", eval_source: "stage8.input.stage7.InstructionRa_10", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_11", oracle: "InstructionRa_11", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_11", eval_source: "stage8.input.stage7.InstructionRa_11", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_12", oracle: "InstructionRa_12", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_12", eval_source: "stage8.input.stage7.InstructionRa_12", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_13", oracle: "InstructionRa_13", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_13", eval_source: "stage8.input.stage7.InstructionRa_13", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_14", oracle: "InstructionRa_14", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_14", eval_source: "stage8.input.stage7.InstructionRa_14", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_15", oracle: "InstructionRa_15", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_15", eval_source: "stage8.input.stage7.InstructionRa_15", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_16", oracle: "InstructionRa_16", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_16", eval_source: "stage8.input.stage7.InstructionRa_16", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_17", oracle: "InstructionRa_17", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_17", eval_source: "stage8.input.stage7.InstructionRa_17", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_18", oracle: "InstructionRa_18", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_18", eval_source: "stage8.input.stage7.InstructionRa_18", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_19", oracle: "InstructionRa_19", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_19", eval_source: "stage8.input.stage7.InstructionRa_19", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_20", oracle: "InstructionRa_20", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_20", eval_source: "stage8.input.stage7.InstructionRa_20", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_21", oracle: "InstructionRa_21", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_21", eval_source: "stage8.input.stage7.InstructionRa_21", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_22", oracle: "InstructionRa_22", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_22", eval_source: "stage8.input.stage7.InstructionRa_22", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_23", oracle: "InstructionRa_23", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_23", eval_source: "stage8.input.stage7.InstructionRa_23", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_24", oracle: "InstructionRa_24", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_24", eval_source: "stage8.input.stage7.InstructionRa_24", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_25", oracle: "InstructionRa_25", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_25", eval_source: "stage8.input.stage7.InstructionRa_25", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_26", oracle: "InstructionRa_26", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_26", eval_source: "stage8.input.stage7.InstructionRa_26", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_27", oracle: "InstructionRa_27", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_27", eval_source: "stage8.input.stage7.InstructionRa_27", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_28", oracle: "InstructionRa_28", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_28", eval_source: "stage8.input.stage7.InstructionRa_28", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_29", oracle: "InstructionRa_29", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_29", eval_source: "stage8.input.stage7.InstructionRa_29", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_30", oracle: "InstructionRa_30", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_30", eval_source: "stage8.input.stage7.InstructionRa_30", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.InstructionRa_31", oracle: "InstructionRa_31", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.InstructionRa_31", eval_source: "stage8.input.stage7.InstructionRa_31", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_0", oracle: "BytecodeRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_0", eval_source: "stage8.input.stage7.BytecodeRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_1", oracle: "BytecodeRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_1", eval_source: "stage8.input.stage7.BytecodeRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.BytecodeRa_2", oracle: "BytecodeRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.BytecodeRa_2", eval_source: "stage8.input.stage7.BytecodeRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_0", oracle: "RamRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_0", eval_source: "stage8.input.stage7.RamRa_0", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_0" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_1", oracle: "RamRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_1", eval_source: "stage8.input.stage7.RamRa_1", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_1" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_2", oracle: "RamRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_2", eval_source: "stage8.input.stage7.RamRa_2", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_2" }, - Stage8OpeningClaimPlan { symbol: "stage8.evaluation.opening.RamRa_3", oracle: "RamRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: "stage8.input.stage7.RamRa_3", eval_source: "stage8.input.stage7.RamRa_3", source_stage: "stage7", source_claim: "stage7.hamming_weight_claim_reduction.eval.RamRa_3" }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamInc"), oracle: "RamInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RamInc") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RdInc"), oracle: "RdInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RdInc") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_0"), oracle: "InstructionRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_1"), oracle: "InstructionRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_2"), oracle: "InstructionRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_3"), oracle: "InstructionRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_4"), oracle: "InstructionRa_4", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_5"), oracle: "InstructionRa_5", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_6"), oracle: "InstructionRa_6", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_7"), oracle: "InstructionRa_7", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_8"), oracle: "InstructionRa_8", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_9"), oracle: "InstructionRa_9", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_10"), oracle: "InstructionRa_10", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_11"), oracle: "InstructionRa_11", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_12"), oracle: "InstructionRa_12", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_13"), oracle: "InstructionRa_13", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_14"), oracle: "InstructionRa_14", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_15"), oracle: "InstructionRa_15", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_16"), oracle: "InstructionRa_16", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_17"), oracle: "InstructionRa_17", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_18"), oracle: "InstructionRa_18", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_19"), oracle: "InstructionRa_19", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_20"), oracle: "InstructionRa_20", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_21"), oracle: "InstructionRa_21", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_22"), oracle: "InstructionRa_22", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_23"), oracle: "InstructionRa_23", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_24"), oracle: "InstructionRa_24", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_25"), oracle: "InstructionRa_25", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_26"), oracle: "InstructionRa_26", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_27"), oracle: "InstructionRa_27", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_28"), oracle: "InstructionRa_28", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_29"), oracle: "InstructionRa_29", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_30"), oracle: "InstructionRa_30", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_31"), oracle: "InstructionRa_31", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_0"), oracle: "BytecodeRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_1"), oracle: "BytecodeRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_2"), oracle: "BytecodeRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_0"), oracle: "RamRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_0") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_1"), oracle: "RamRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_1") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_2"), oracle: "RamRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_2") }, + Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_3"), oracle: "RamRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_3") }, ]; -pub const STAGE8_OPENING_BATCH_ORDERED_CLAIMS: &[&str] = &["stage8.evaluation.opening.RamInc", "stage8.evaluation.opening.RdInc", "stage8.evaluation.opening.InstructionRa_0", "stage8.evaluation.opening.InstructionRa_1", "stage8.evaluation.opening.InstructionRa_2", "stage8.evaluation.opening.InstructionRa_3", "stage8.evaluation.opening.InstructionRa_4", "stage8.evaluation.opening.InstructionRa_5", "stage8.evaluation.opening.InstructionRa_6", "stage8.evaluation.opening.InstructionRa_7", "stage8.evaluation.opening.InstructionRa_8", "stage8.evaluation.opening.InstructionRa_9", "stage8.evaluation.opening.InstructionRa_10", "stage8.evaluation.opening.InstructionRa_11", "stage8.evaluation.opening.InstructionRa_12", "stage8.evaluation.opening.InstructionRa_13", "stage8.evaluation.opening.InstructionRa_14", "stage8.evaluation.opening.InstructionRa_15", "stage8.evaluation.opening.InstructionRa_16", "stage8.evaluation.opening.InstructionRa_17", "stage8.evaluation.opening.InstructionRa_18", "stage8.evaluation.opening.InstructionRa_19", "stage8.evaluation.opening.InstructionRa_20", "stage8.evaluation.opening.InstructionRa_21", "stage8.evaluation.opening.InstructionRa_22", "stage8.evaluation.opening.InstructionRa_23", "stage8.evaluation.opening.InstructionRa_24", "stage8.evaluation.opening.InstructionRa_25", "stage8.evaluation.opening.InstructionRa_26", "stage8.evaluation.opening.InstructionRa_27", "stage8.evaluation.opening.InstructionRa_28", "stage8.evaluation.opening.InstructionRa_29", "stage8.evaluation.opening.InstructionRa_30", "stage8.evaluation.opening.InstructionRa_31", "stage8.evaluation.opening.BytecodeRa_0", "stage8.evaluation.opening.BytecodeRa_1", "stage8.evaluation.opening.BytecodeRa_2", "stage8.evaluation.opening.RamRa_0", "stage8.evaluation.opening.RamRa_1", "stage8.evaluation.opening.RamRa_2", "stage8.evaluation.opening.RamRa_3"]; - -pub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = Stage8OpeningBatchPlan { symbol: "stage8.evaluation.openings", proof_slot: "stage8.evaluation", policy: "jolt_stage8_joint_rlc", count: 41, ordered_claims: STAGE8_OPENING_BATCH_ORDERED_CLAIMS }; +#[rustfmt::skip] +pub const STAGE8_OPENING_BATCH: Stage8OpeningBatchPlan = Stage8OpeningBatchPlan { symbol: Stage8OpeningBatchSymbol::new("stage8.evaluation.openings"), proof_slot: "stage8.evaluation", policy: "jolt_stage8_joint_rlc", count: 41, ordered_claims: STAGE8_OPENING_CLAIMS }; -pub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = Stage8PcsProofPlan { symbol: "stage8.evaluation.proof", mode: "verify", pcs: "dory", proof_slot: "stage8.evaluation", transcript_label: "rlc_claims", batch: "stage8.evaluation.openings" }; +#[rustfmt::skip] +pub const STAGE8_PCS_PROOF: Stage8PcsProofPlan = Stage8PcsProofPlan { symbol: "stage8.evaluation.proof", mode: Stage8PcsProofMode::Verify, pcs: "dory", proof_slot: "stage8.evaluation", transcript_label: "rlc_claims", batch: Stage8OpeningBatchSymbol::new("stage8.evaluation.openings") }; -pub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan { - role: "verifier", - function: "jolt.stage8", - params: STAGE8_PARAMS, - evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE, - opening_inputs: STAGE8_OPENING_INPUTS, - opening_claims: STAGE8_OPENING_CLAIMS, - opening_batch: STAGE8_OPENING_BATCH, - pcs_proof: STAGE8_PCS_PROOF, -}; +#[rustfmt::skip] +pub const STAGE8_PROGRAM: Stage8EvaluationProgramPlan = Stage8EvaluationProgramPlan { role: "verifier", function: "jolt.stage8", params: STAGE8_PARAMS, evaluation_point_source: STAGE8_EVALUATION_POINT_SOURCE, opening_inputs: STAGE8_OPENING_INPUTS, opening_claims: STAGE8_OPENING_CLAIMS, opening_batch: STAGE8_OPENING_BATCH, pcs_proof: STAGE8_PCS_PROOF }; diff --git a/crates/jolt-verifier/src/verifier.rs b/crates/jolt-verifier/src/verifier.rs index 1518cd618c..ede5adcc39 100644 --- a/crates/jolt-verifier/src/verifier.rs +++ b/crates/jolt-verifier/src/verifier.rs @@ -4,7 +4,7 @@ use jolt_dory::{DoryCommitment, DoryProof, DoryScheme, DoryVerifierSetup}; use jolt_field::Fr; use jolt_openings::{AdditivelyHomomorphic, CommitmentScheme, OpeningsError}; use jolt_poly::EqPolynomial; -use jolt_transcript::{AppendToTranscript, LabelWithCount, Transcript}; +use jolt_transcript::Transcript; use crate::stages::{commitment as commitment_stage, stage1_outer as stage1_outer_stage, stage2 as stage2_stage, stage3 as stage3_stage, stage4 as stage4_stage, stage5 as stage5_stage, stage6 as stage6_stage, stage7 as stage7_stage, stage8 as stage8_stage}; @@ -250,6 +250,59 @@ pub type JoltStage6BytecodeEntry = crate::stages::stage6::Stage6BytecodeEntry; pub type JoltStage6BytecodeReadRafData = crate::stages::stage6::Stage6BytecodeReadRafData; pub type JoltStage6VerifierData = crate::stages::stage6::Stage6VerifierData; +impl stage8_stage::Stage8NamedEvalView for JoltNamedEval { + fn name(&self) -> &'static str { + self.name + } + + fn value(&self) -> Fr { + self.value + } +} + +impl stage8_stage::Stage8SumcheckOutputView for JoltSumcheckOutput { + type Eval = JoltNamedEval; + + fn point(&self) -> &[Fr] { + &self.point + } + + fn evals(&self) -> &[Self::Eval] { + &self.evals + } +} + +impl stage8_stage::Stage8OpeningInputView + for stage7_stage::Stage7OpeningInputValue +{ + fn symbol(&self) -> &'static str { + self.symbol + } + + fn point(&self) -> &[Fr] { + &self.point + } +} + +impl From for JoltEvaluationProofError { + fn from(error: stage8_stage::Stage8EvaluationOpeningPointError) -> Self { + match error { + stage8_stage::Stage8EvaluationOpeningPointError::MissingStage7EvaluationPoint => { + Self::MissingStage7EvaluationPoint + } + stage8_stage::Stage8EvaluationOpeningPointError::InvalidPointLength { + artifact, + expected, + actual, + } => Self::InvalidPointLength { + artifact, + expected, + actual, + }, + } + } +} + #[expect( clippy::too_many_arguments, reason = "generated verifier entry point follows the Jolt proof artifact boundary" @@ -297,11 +350,6 @@ struct EvaluationProofState { joint_commitment: DoryCommitment, } -struct EvaluationClaim { - oracle: &'static str, - value: Fr, -} - fn evaluation_proof_state( program: &'static stage8_stage::Stage8EvaluationProgramPlan, commitments: &commitment_stage::CommitmentArtifacts, @@ -313,14 +361,22 @@ fn evaluation_proof_state( where T: Transcript, { - let (sumcheck_address_point, stage7_values) = stage7_claim_values(program, stage7)?; - let address_point = reverse_point(&sumcheck_address_point); - let opening_point = stage7_evaluation_opening_point(program, &address_point, stage7_openings)?; + let (sumcheck_address_point, stage7_values) = + stage8_stage::stage7_claim_values(program, &stage7.sumchecks) + .ok_or(JoltEvaluationProofError::MissingStage7RaEval)?; + let address_point = stage8_stage::reverse_point(&sumcheck_address_point); + let (opening_point, _) = + stage8_stage::stage7_evaluation_opening_point(program, &address_point, stage7_openings)?; let lagrange_factor = EqPolynomial::::zero_selector(&address_point); - let claims = evaluation_claims(program, stage6, &stage7_values, lagrange_factor)?; - - append_rlc_claims(transcript, &claims); - let gamma_powers = gamma_powers(transcript, claims.len()); + let claims = + stage8_stage::evaluation_claims(program, &stage6.sumchecks, &stage7_values, lagrange_factor) + .map_err(|error| JoltEvaluationProofError::MissingStageEval { + stage: error.stage, + eval: error.eval, + })?; + + stage8_stage::append_rlc_claims(transcript, &claims); + let gamma_powers = stage8_stage::gamma_powers(transcript, claims.len()); let joint_claim = claims .iter() .zip(&gamma_powers) @@ -335,130 +391,9 @@ where }) } -fn stage_eval( - proof: &JoltStageProof, - stage: &'static str, - eval_name: &'static str, -) -> Result { - for output in &proof.sumchecks { - if let Some(eval) = output.evals.iter().find(|eval| eval.name == eval_name) { - return Ok(eval.value); - } - } - Err(JoltEvaluationProofError::MissingStageEval { - stage, - eval: eval_name, - }) -} - -fn evaluation_claims( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - stage6: &JoltStageProof, - stage7_values: &BTreeMap<&'static str, Fr>, - lagrange_factor: Fr, -) -> Result, JoltEvaluationProofError> { - let mut claims = Vec::with_capacity(program.opening_claims.len()); - for plan in program.opening_claims { - let value = match plan.source_stage { - "stage6" => stage_eval(stage6, plan.source_stage, plan.source_claim)? * lagrange_factor, - "stage7" => *stage7_values.get(plan.source_claim).ok_or( - JoltEvaluationProofError::MissingStageEval { - stage: plan.source_stage, - eval: plan.source_claim, - }, - )?, - _ => { - return Err(JoltEvaluationProofError::MissingStageEval { - stage: plan.source_stage, - eval: plan.source_claim, - }); - } - }; - claims.push(EvaluationClaim { - oracle: plan.oracle, - value, - }); - } - Ok(claims) -} - -fn stage7_claim_values( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - proof: &JoltStageProof, -) -> Result<(Vec, BTreeMap<&'static str, Fr>), JoltEvaluationProofError> { - let stage7_plans = program - .opening_claims - .iter() - .filter(|plan| plan.source_stage == "stage7") - .collect::>(); - for output in &proof.sumchecks { - let mut values = BTreeMap::new(); - for plan in &stage7_plans { - if let Some(eval) = output.evals.iter().find(|eval| eval.name == plan.source_claim) { - let _ = values.insert(plan.source_claim, eval.value); - } - } - if values.len() == stage7_plans.len() { - return Ok((output.point.clone(), values)); - } - } - Err(JoltEvaluationProofError::MissingStage7RaEval) -} - -fn reverse_point(point: &[Fr]) -> Vec { - point.iter().rev().copied().collect() -} - -fn stage7_evaluation_opening_point( - program: &'static stage8_stage::Stage8EvaluationProgramPlan, - address_point: &[Fr], - stage7_openings: &[stage7_stage::Stage7OpeningInputValue], -) -> Result, JoltEvaluationProofError> { - let cycle_source_symbol = program.evaluation_point_source.source_claim; - let cycle_source = stage7_openings - .iter() - .find(|input| input.symbol == cycle_source_symbol) - .ok_or(JoltEvaluationProofError::MissingStage7EvaluationPoint)?; - if cycle_source.point.len() < address_point.len() { - return Err(JoltEvaluationProofError::InvalidPointLength { - artifact: cycle_source_symbol, - expected: address_point.len(), - actual: cycle_source.point.len(), - }); - } - let mut point = Vec::with_capacity(cycle_source.point.len()); - point.extend_from_slice(address_point); - point.extend_from_slice(&cycle_source.point[address_point.len()..]); - Ok(point) -} - -fn append_rlc_claims(transcript: &mut T, claims: &[EvaluationClaim]) -where - T: Transcript, -{ - transcript.append(&LabelWithCount(b"rlc_claims", claims.len() as u64)); - for claim in claims { - claim.value.append_to_transcript(transcript); - } -} - -fn gamma_powers(transcript: &mut T, count: usize) -> Vec -where - T: Transcript, -{ - let gamma = transcript.challenge(); - let mut powers = Vec::with_capacity(count); - let mut power = Fr::from_u64(1); - for _ in 0..count { - powers.push(power); - power *= gamma; - } - powers -} - fn joint_commitment( commitments: &commitment_stage::CommitmentArtifacts, - claims: &[EvaluationClaim], + claims: &[stage8_stage::Stage8EvaluationClaim], gamma_powers: &[Fr], ) -> Result { let mut coefficients = BTreeMap::<&'static str, Fr>::new(); From 30a2c4819f2f402afe4d37d7e3ad95dc0ac0ff4b Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 18:07:57 -0600 Subject: [PATCH 002/171] test(bolt): enforce zero verifier relation string sites --- crates/bolt/src/protocols/jolt/emit/rust/stage2.rs | 8 ++++---- crates/bolt/tests/verifier_cleanup.rs | 8 +++----- crates/jolt-verifier/src/stages/stage2.rs | 8 ++++---- 3 files changed, 11 insertions(+), 13 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index f3b73cc8b3..ed2f5cfbf7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -998,7 +998,7 @@ pub enum VerifyStage2Error { InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, UnsupportedRelation { relation: Stage2RelationKind }, - MissingRam { relation: &'static str }, + MissingRam { context: &'static str }, Sumcheck { driver: &'static str, error: SumcheckError }, } @@ -2256,7 +2256,7 @@ fn expected_ram_raf( ram: Option<&Stage2RamData<'_>>, ) -> Result { let ram = ram.ok_or(VerifyStage2Error::MissingRam { - relation: "jolt.stage2.ram.raf_evaluation", + context: "stage2.ram.raf_evaluation", })?; let address = reverse_slice(local_point); let unmap = unmap_eval(ram.log_k, ram.start_address, &address); @@ -2270,10 +2270,10 @@ fn expected_ram_output( ram: Option<&Stage2RamData<'_>>, ) -> Result { let ram = ram.ok_or(VerifyStage2Error::MissingRam { - relation: "jolt.stage2.ram.output_check", + context: "stage2.ram.output_check", })?; let layout = ram.output_layout.ok_or(VerifyStage2Error::MissingRam { - relation: "jolt.stage2.ram.output_check.layout", + context: "stage2.ram.output_check.layout", })?; let r_address = store.point("stage2.ram_output.r_address")?; let opening_point = reverse_slice(local_point); diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 1a8318501f..22304ce85f 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -19,7 +19,7 @@ const STAGE6_STAGE7_BASELINE_LOC_CEILING: usize = STAGE6_STAGE7_TARGET_LOC; const STAGE_LOCAL_PLAN_STRUCT_BASELINE_CEILING: usize = 18; const FIELD_EXPR_OPERAND_CONSTANT_BASELINE_CEILING: usize = 0; const STAGE_HELPER_FUNCTION_BASELINE_CEILING: usize = 38; -const RELATION_STRING_SITE_BASELINE_CEILING: usize = 72; +const RELATION_STRING_SITE_BASELINE_CEILING: usize = 0; const ALLOWED_JOLT_PROTOCOL_SYMBOLS: &[&str] = &[ "jolt.commitment_phase", @@ -495,11 +495,9 @@ fn count_relation_string_sites(source: &str) -> usize { source .lines() .filter(|line| { - line.contains("match instance.relation") - || line.contains("match claim.relation") - || line.contains("match driver.relation") - || line.contains("relation: Some(\"jolt.") + line.contains("relation: Some(\"jolt.") || line.contains("relation: \"jolt.") + || line.contains("relation == \"jolt.") }) .count() } diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index 6818946666..a87435a0b5 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -70,7 +70,7 @@ pub enum VerifyStage2Error { InvalidInputLength { input: &'static str, expected: usize, actual: usize }, InvalidProof { driver: &'static str, reason: &'static str }, UnsupportedRelation { relation: Stage2RelationKind }, - MissingRam { relation: &'static str }, + MissingRam { context: &'static str }, Sumcheck { driver: &'static str, error: SumcheckError }, } @@ -785,7 +785,7 @@ fn expected_ram_raf( ram: Option<&Stage2RamData<'_>>, ) -> Result { let ram = ram.ok_or(VerifyStage2Error::MissingRam { - relation: "jolt.stage2.ram.raf_evaluation", + context: "stage2.ram.raf_evaluation", })?; let address = reverse_slice(local_point); let unmap = unmap_eval(ram.log_k, ram.start_address, &address); @@ -799,10 +799,10 @@ fn expected_ram_output( ram: Option<&Stage2RamData<'_>>, ) -> Result { let ram = ram.ok_or(VerifyStage2Error::MissingRam { - relation: "jolt.stage2.ram.output_check", + context: "stage2.ram.output_check", })?; let layout = ram.output_layout.ok_or(VerifyStage2Error::MissingRam { - relation: "jolt.stage2.ram.output_check.layout", + context: "stage2.ram.output_check.layout", })?; let r_address = store.point("stage2.ram_output.r_address")?; let opening_point = reverse_slice(local_point); From 241474be61146b88f705c20e5ddfe7ec748cdf2e Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 18:13:04 -0600 Subject: [PATCH 003/171] refactor(bolt): derive typed verifier symbol traits --- .../src/protocols/jolt/emit/rust/stage8.rs | 4 +++ .../jolt/verifier_common.rs.template | 30 +------------------ crates/jolt-verifier/src/stages/common.rs | 30 +------------------ crates/jolt-verifier/src/stages/stage8.rs | 4 +++ 4 files changed, 10 insertions(+), 58 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs index 4d19a26a70..326c2f6ece 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs @@ -294,12 +294,16 @@ impl Stage8CpuProgram { match self.role { Role::Verifier => source.push_str( "pub use super::common::{ClaimKind as Stage8ClaimKind, PcsProofMode as Stage8PcsProofMode, SourceStage as Stage8SourceStage, StageParams as Stage8Params, TypedPlanSymbol};\n\n\ + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\n\ pub enum Stage8OpeningInputTag {}\n\ pub type Stage8OpeningInputSymbol = TypedPlanSymbol;\n\ + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\n\ pub enum Stage8OpeningClaimTag {}\n\ pub type Stage8OpeningClaimSymbol = TypedPlanSymbol;\n\ + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\n\ pub enum Stage8OpeningBatchTag {}\n\ pub type Stage8OpeningBatchSymbol = TypedPlanSymbol;\n\ + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\n\ pub enum Stage8SourceClaimTag {}\n\ pub type Stage8SourceClaim = TypedPlanSymbol;\n\n", ), diff --git a/crates/bolt/src/protocols/jolt/verifier_common.rs.template b/crates/bolt/src/protocols/jolt/verifier_common.rs.template index 91b706f1dc..c318d45d50 100644 --- a/crates/bolt/src/protocols/jolt/verifier_common.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_common.rs.template @@ -3,7 +3,6 @@ reason = "generated verifier helpers mirror staged protocol ABIs" )] -use std::cmp::Ordering; use std::fmt; use std::marker::PhantomData; @@ -22,6 +21,7 @@ pub struct StageParams { pub transcript: &'static str, } +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub struct TypedPlanSymbol { symbol: &'static str, _tag: PhantomData Tag>, @@ -40,14 +40,6 @@ impl TypedPlanSymbol { } } -impl Clone for TypedPlanSymbol { - fn clone(&self) -> Self { - *self - } -} - -impl Copy for TypedPlanSymbol {} - impl fmt::Debug for TypedPlanSymbol { fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { formatter @@ -57,26 +49,6 @@ impl fmt::Debug for TypedPlanSymbol { } } -impl PartialEq for TypedPlanSymbol { - fn eq(&self, other: &Self) -> bool { - self.symbol == other.symbol - } -} - -impl Eq for TypedPlanSymbol {} - -impl PartialOrd for TypedPlanSymbol { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } -} - -impl Ord for TypedPlanSymbol { - fn cmp(&self, other: &Self) -> Ordering { - self.symbol.cmp(other.symbol) - } -} - #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct KernelPlan { pub symbol: &'static str, diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs index 91b706f1dc..c318d45d50 100644 --- a/crates/jolt-verifier/src/stages/common.rs +++ b/crates/jolt-verifier/src/stages/common.rs @@ -3,7 +3,6 @@ reason = "generated verifier helpers mirror staged protocol ABIs" )] -use std::cmp::Ordering; use std::fmt; use std::marker::PhantomData; @@ -22,6 +21,7 @@ pub struct StageParams { pub transcript: &'static str, } +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub struct TypedPlanSymbol { symbol: &'static str, _tag: PhantomData Tag>, @@ -40,14 +40,6 @@ impl TypedPlanSymbol { } } -impl Clone for TypedPlanSymbol { - fn clone(&self) -> Self { - *self - } -} - -impl Copy for TypedPlanSymbol {} - impl fmt::Debug for TypedPlanSymbol { fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { formatter @@ -57,26 +49,6 @@ impl fmt::Debug for TypedPlanSymbol { } } -impl PartialEq for TypedPlanSymbol { - fn eq(&self, other: &Self) -> bool { - self.symbol == other.symbol - } -} - -impl Eq for TypedPlanSymbol {} - -impl PartialOrd for TypedPlanSymbol { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } -} - -impl Ord for TypedPlanSymbol { - fn cmp(&self, other: &Self) -> Ordering { - self.symbol.cmp(other.symbol) - } -} - #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct KernelPlan { pub symbol: &'static str, diff --git a/crates/jolt-verifier/src/stages/stage8.rs b/crates/jolt-verifier/src/stages/stage8.rs index 4e846856e8..7f4ce85a4d 100644 --- a/crates/jolt-verifier/src/stages/stage8.rs +++ b/crates/jolt-verifier/src/stages/stage8.rs @@ -2,12 +2,16 @@ pub use super::common::{ClaimKind as Stage8ClaimKind, PcsProofMode as Stage8PcsProofMode, SourceStage as Stage8SourceStage, StageParams as Stage8Params, TypedPlanSymbol}; +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub enum Stage8OpeningInputTag {} pub type Stage8OpeningInputSymbol = TypedPlanSymbol; +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub enum Stage8OpeningClaimTag {} pub type Stage8OpeningClaimSymbol = TypedPlanSymbol; +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub enum Stage8OpeningBatchTag {} pub type Stage8OpeningBatchSymbol = TypedPlanSymbol; +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub enum Stage8SourceClaimTag {} pub type Stage8SourceClaim = TypedPlanSymbol; From 9375f35fcdad168e8d901f68a420062109d2206c Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 18:21:01 -0600 Subject: [PATCH 004/171] refactor(bolt): structure verifier field expression operands --- .../protocols/jolt/emit/rust/plan_tokens.rs | 12 ++ .../src/protocols/jolt/emit/rust/stage2.rs | 2 +- .../src/protocols/jolt/emit/rust/stage3.rs | 2 +- .../src/protocols/jolt/emit/rust/stage4.rs | 2 +- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../src/protocols/jolt/emit/rust/stage6.rs | 4 +- .../src/protocols/jolt/emit/rust/stage7.rs | 4 +- .../jolt/verifier_common.rs.template | 7 +- crates/jolt-verifier/src/stages/common.rs | 7 +- crates/jolt-verifier/src/stages/stage2.rs | 42 +++---- crates/jolt-verifier/src/stages/stage3.rs | 38 +++--- crates/jolt-verifier/src/stages/stage4.rs | 18 +-- crates/jolt-verifier/src/stages/stage5.rs | 20 +-- crates/jolt-verifier/src/stages/stage6.rs | 114 +++++++++--------- crates/jolt-verifier/src/stages/stage7.rs | 90 +++++++------- 15 files changed, 185 insertions(+), 179 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index 24f7015bdd..3eacf95087 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -45,6 +45,18 @@ pub(super) fn role_field_expr_kind_expr( field_expr_kind_expr(stage_type_prefix, formula) } +pub(super) fn rust_str_slice_expr(values: &[String]) -> String { + if values.is_empty() { + return "&[]".to_owned(); + } + let values = values + .iter() + .map(|value| format!("{value:?}")) + .collect::>() + .join(", "); + format!("&[{values}]") +} + pub(super) fn role_relation_kind_expr( stage_type_prefix: &str, role: &Role, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index ed2f5cfbf7..2a67a18fa7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -1183,7 +1183,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); &self.role, &expr.formula )?, - rust_str(&expr.operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&expr.operands) )) }) .collect::, EmitError>>()? diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 66e09478b9..c2243ccfef 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1187,7 +1187,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); &self.role, &expr.formula )?, - rust_str(&expr.operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&expr.operands) )) }) .collect::, EmitError>>()? diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index baa507ef5e..f5e2d896d3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -1404,7 +1404,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); &self.role, &expr.formula )?, - rust_str(&expr.operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&expr.operands) )) }) .collect::, EmitError>>()? diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 0ca24dc9ec..3d65786c34 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1406,7 +1406,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); &self.role, &expr.formula )?, - rust_str(&expr.operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&expr.operands) )) }) .collect::, EmitError>>()? diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 132cd5310d..c2f5976d85 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1542,7 +1542,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); &self.role, &expr.formula )?, - rust_str(&expr.operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&expr.operands) )) }) .collect::, EmitError>>()? @@ -1552,7 +1552,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); .collect::, EmitError>>()? .join("\n"); return Ok(format!( - "macro_rules! stage6_field_expr {{\n ($symbol:literal, $kind:expr, $operands:literal) => {{\n Stage6FieldExprPlan {{ symbol: $symbol, kind: $kind, operands: $operands }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[\n{rows}\n];\n" + "macro_rules! stage6_field_expr {{\n ($symbol:literal, $kind:expr, $operands:expr) => {{\n Stage6FieldExprPlan {{ symbol: $symbol, kind: $kind, operands: $operands }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[\n{rows}\n];\n" )); } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index f21dea8200..09d372b288 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1438,7 +1438,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); &self.role, &expr.formula )?, - rust_str(&expr.operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&expr.operands) )) }) .collect::, EmitError>>()? @@ -1448,7 +1448,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); .collect::, EmitError>>()? .join("\n"); return Ok(format!( - "macro_rules! stage7_field_expr {{\n ($symbol:literal, $kind:expr, $operands:literal) => {{\n Stage7FieldExprPlan {{ symbol: $symbol, kind: $kind, operands: $operands }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[\n{rows}\n];\n" + "macro_rules! stage7_field_expr {{\n ($symbol:literal, $kind:expr, $operands:expr) => {{\n Stage7FieldExprPlan {{ symbol: $symbol, kind: $kind, operands: $operands }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[\n{rows}\n];\n" )); } diff --git a/crates/bolt/src/protocols/jolt/verifier_common.rs.template b/crates/bolt/src/protocols/jolt/verifier_common.rs.template index c318d45d50..c67b3876da 100644 --- a/crates/bolt/src/protocols/jolt/verifier_common.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_common.rs.template @@ -163,7 +163,7 @@ pub enum FieldExprKind { pub struct FieldExprPlan { pub symbol: &'static str, pub kind: FieldExprKind, - pub operands: &'static str, + pub operands: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -832,11 +832,8 @@ impl ValueStore { } fn try_expr_operands(&self, expr: &FieldExprPlan) -> Option> { - if expr.operands.is_empty() { - return Some(Vec::new()); - } expr.operands - .split('|') + .iter() .map(|operand| self.try_scalar(operand)) .collect() } diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs index c318d45d50..c67b3876da 100644 --- a/crates/jolt-verifier/src/stages/common.rs +++ b/crates/jolt-verifier/src/stages/common.rs @@ -163,7 +163,7 @@ pub enum FieldExprKind { pub struct FieldExprPlan { pub symbol: &'static str, pub kind: FieldExprKind, - pub operands: &'static str, + pub operands: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -832,11 +832,8 @@ impl ValueStore { } fn try_expr_operands(&self, expr: &FieldExprPlan) -> Option> { - if expr.operands.is_empty() { - return Some(Vec::new()); - } expr.operands - .split('|') + .iter() .map(|operand| self.try_scalar(operand)) .collect() } diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index a87435a0b5..b6dc0090a2 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -112,27 +112,27 @@ pub const STAGE2_FIELD_CONSTANTS: &[Stage2FieldConstantPlan] = &[ ]; pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.Product", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 0), operands: "stage2.product_virtual.tau_high" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldBranch", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 1), operands: "stage2.product_virtual.tau_high" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldJump", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 2), operands: "stage2.product_virtual.tau_high" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.Product", kind: Stage2FieldExprKind::Mul, operands: "stage2.product_virtual.uniskip.weight.Product|stage2.input.stage1.Product" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldBranch", kind: Stage2FieldExprKind::Mul, operands: "stage2.product_virtual.uniskip.weight.ShouldBranch|stage2.input.stage1.ShouldBranch" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldJump", kind: Stage2FieldExprKind::Mul, operands: "stage2.product_virtual.uniskip.weight.ShouldJump|stage2.input.stage1.ShouldJump" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.partial.ProductShouldBranch", kind: Stage2FieldExprKind::Add, operands: "stage2.product_virtual.uniskip.term.Product|stage2.product_virtual.uniskip.term.ShouldBranch" }, - Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.claim_expr", kind: Stage2FieldExprKind::Add, operands: "stage2.product_virtual.uniskip.partial.ProductShouldBranch|stage2.product_virtual.uniskip.term.ShouldJump" }, - Stage2FieldExprPlan { symbol: "stage2.ram_read_write.term.RamWriteValue", kind: Stage2FieldExprKind::Mul, operands: "stage2.ram_read_write.gamma|stage2.input.stage1.RamWriteValue" }, - Stage2FieldExprPlan { symbol: "stage2.ram_read_write.claim_expr", kind: Stage2FieldExprKind::Add, operands: "stage2.input.stage1.RamReadValue|stage2.ram_read_write.term.RamWriteValue" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma2", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma|stage2.instruction_lookup.gamma" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma3", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma2|stage2.instruction_lookup.gamma" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma4", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma2|stage2.instruction_lookup.gamma2" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftLookupOperand", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma|stage2.input.stage1.LeftLookupOperand" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightLookupOperand", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma2|stage2.input.stage1.RightLookupOperand" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftInstructionInput", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma3|stage2.input.stage1.LeftInstructionInput" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightInstructionInput", kind: Stage2FieldExprKind::Mul, operands: "stage2.instruction_lookup.gamma4|stage2.input.stage1.RightInstructionInput" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LookupOutputLeftOperand", kind: Stage2FieldExprKind::Add, operands: "stage2.input.stage1.LookupOutput|stage2.instruction_lookup.term.LeftLookupOperand" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.RightOperand", kind: Stage2FieldExprKind::Add, operands: "stage2.instruction_lookup.partial.LookupOutputLeftOperand|stage2.instruction_lookup.term.RightLookupOperand" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LeftInstructionInput", kind: Stage2FieldExprKind::Add, operands: "stage2.instruction_lookup.partial.RightOperand|stage2.instruction_lookup.term.LeftInstructionInput" }, - Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: Stage2FieldExprKind::Add, operands: "stage2.instruction_lookup.partial.LeftInstructionInput|stage2.instruction_lookup.term.RightInstructionInput" }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.Product", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 0), operands: &["stage2.product_virtual.tau_high"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldBranch", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 1), operands: &["stage2.product_virtual.tau_high"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.weight.ShouldJump", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 2), operands: &["stage2.product_virtual.tau_high"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.Product", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.uniskip.weight.Product", "stage2.input.stage1.Product"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldBranch", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.uniskip.weight.ShouldBranch", "stage2.input.stage1.ShouldBranch"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.term.ShouldJump", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.uniskip.weight.ShouldJump", "stage2.input.stage1.ShouldJump"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.partial.ProductShouldBranch", kind: Stage2FieldExprKind::Add, operands: &["stage2.product_virtual.uniskip.term.Product", "stage2.product_virtual.uniskip.term.ShouldBranch"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.uniskip.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.product_virtual.uniskip.partial.ProductShouldBranch", "stage2.product_virtual.uniskip.term.ShouldJump"] }, + Stage2FieldExprPlan { symbol: "stage2.ram_read_write.term.RamWriteValue", kind: Stage2FieldExprKind::Mul, operands: &["stage2.ram_read_write.gamma", "stage2.input.stage1.RamWriteValue"] }, + Stage2FieldExprPlan { symbol: "stage2.ram_read_write.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.input.stage1.RamReadValue", "stage2.ram_read_write.term.RamWriteValue"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma2", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma", "stage2.instruction_lookup.gamma"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma3", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma2", "stage2.instruction_lookup.gamma"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.gamma4", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma2", "stage2.instruction_lookup.gamma2"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftLookupOperand", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma", "stage2.input.stage1.LeftLookupOperand"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightLookupOperand", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma2", "stage2.input.stage1.RightLookupOperand"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.LeftInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma3", "stage2.input.stage1.LeftInstructionInput"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.term.RightInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma4", "stage2.input.stage1.RightInstructionInput"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LookupOutputLeftOperand", kind: Stage2FieldExprKind::Add, operands: &["stage2.input.stage1.LookupOutput", "stage2.instruction_lookup.term.LeftLookupOperand"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.RightOperand", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.LookupOutputLeftOperand", "stage2.instruction_lookup.term.RightLookupOperand"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LeftInstructionInput", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.RightOperand", "stage2.instruction_lookup.term.LeftInstructionInput"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.LeftInstructionInput", "stage2.instruction_lookup.term.RightInstructionInput"] }, ]; pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[ Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr", input_openings: "stage2.input.stage1.Product|stage2.input.stage1.ShouldBranch|stage2.input.stage1.ShouldJump" }, diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 3e114db8c8..a9a012cf12 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -84,25 +84,25 @@ pub const STAGE3_FIELD_CONSTANTS: &[Stage3FieldConstantPlan] = &[ ]; pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[ - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma2", kind: Stage3FieldExprKind::Pow(2), operands: "stage3.spartan_shift.gamma" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma3", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma2|stage3.spartan_shift.gamma" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma4", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma2|stage3.spartan_shift.gamma2" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextPC", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma|stage3.input.stage1.NextPC" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsVirtual", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma2|stage3.input.stage1.NextIsVirtual" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsFirstInSequence", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma3|stage3.input.stage1.NextIsFirstInSequence" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.one_minus.NextIsNoop", kind: Stage3FieldExprKind::Sub, operands: "stage3.field.one|stage3.input.stage2.product_virtual.NextIsNoop" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsNoop", kind: Stage3FieldExprKind::Mul, operands: "stage3.spartan_shift.gamma4|stage3.spartan_shift.one_minus.NextIsNoop" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextUnexpandedPCNextPC", kind: Stage3FieldExprKind::Add, operands: "stage3.input.stage1.NextUnexpandedPC|stage3.spartan_shift.term.NextPC" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsVirtual", kind: Stage3FieldExprKind::Add, operands: "stage3.spartan_shift.partial.NextUnexpandedPCNextPC|stage3.spartan_shift.term.NextIsVirtual" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsFirstInSequence", kind: Stage3FieldExprKind::Add, operands: "stage3.spartan_shift.partial.NextIsVirtual|stage3.spartan_shift.term.NextIsFirstInSequence" }, - Stage3FieldExprPlan { symbol: "stage3.spartan_shift.claim_expr", kind: Stage3FieldExprKind::Add, operands: "stage3.spartan_shift.partial.NextIsFirstInSequence|stage3.spartan_shift.term.NextIsNoop" }, - Stage3FieldExprPlan { symbol: "stage3.instruction_input.term.LeftInstructionInput", kind: Stage3FieldExprKind::Mul, operands: "stage3.instruction_input.gamma|stage3.input.stage2.product_virtual.LeftInstructionInput" }, - Stage3FieldExprPlan { symbol: "stage3.instruction_input.claim_expr", kind: Stage3FieldExprKind::Add, operands: "stage3.input.stage2.product_virtual.RightInstructionInput|stage3.instruction_input.term.LeftInstructionInput" }, - Stage3FieldExprPlan { symbol: "stage3.registers.gamma2", kind: Stage3FieldExprKind::Pow(2), operands: "stage3.registers.gamma" }, - Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs1Value", kind: Stage3FieldExprKind::Mul, operands: "stage3.registers.gamma|stage3.input.stage1.Rs1Value" }, - Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs2Value", kind: Stage3FieldExprKind::Mul, operands: "stage3.registers.gamma2|stage3.input.stage1.Rs2Value" }, - Stage3FieldExprPlan { symbol: "stage3.registers.partial.RdWriteValueRs1Value", kind: Stage3FieldExprKind::Add, operands: "stage3.input.stage1.RdWriteValue|stage3.registers.term.Rs1Value" }, - Stage3FieldExprPlan { symbol: "stage3.registers.claim_expr", kind: Stage3FieldExprKind::Add, operands: "stage3.registers.partial.RdWriteValueRs1Value|stage3.registers.term.Rs2Value" }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma2", kind: Stage3FieldExprKind::Pow(2), operands: &["stage3.spartan_shift.gamma"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma3", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma2", "stage3.spartan_shift.gamma"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.gamma4", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma2", "stage3.spartan_shift.gamma2"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextPC", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma", "stage3.input.stage1.NextPC"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsVirtual", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma2", "stage3.input.stage1.NextIsVirtual"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsFirstInSequence", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma3", "stage3.input.stage1.NextIsFirstInSequence"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.one_minus.NextIsNoop", kind: Stage3FieldExprKind::Sub, operands: &["stage3.field.one", "stage3.input.stage2.product_virtual.NextIsNoop"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.term.NextIsNoop", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma4", "stage3.spartan_shift.one_minus.NextIsNoop"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextUnexpandedPCNextPC", kind: Stage3FieldExprKind::Add, operands: &["stage3.input.stage1.NextUnexpandedPC", "stage3.spartan_shift.term.NextPC"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsVirtual", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.partial.NextUnexpandedPCNextPC", "stage3.spartan_shift.term.NextIsVirtual"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.partial.NextIsFirstInSequence", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.partial.NextIsVirtual", "stage3.spartan_shift.term.NextIsFirstInSequence"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.partial.NextIsFirstInSequence", "stage3.spartan_shift.term.NextIsNoop"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.term.LeftInstructionInput", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.gamma", "stage3.input.stage2.product_virtual.LeftInstructionInput"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.input.stage2.product_virtual.RightInstructionInput", "stage3.instruction_input.term.LeftInstructionInput"] }, + Stage3FieldExprPlan { symbol: "stage3.registers.gamma2", kind: Stage3FieldExprKind::Pow(2), operands: &["stage3.registers.gamma"] }, + Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs1Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.gamma", "stage3.input.stage1.Rs1Value"] }, + Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs2Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.gamma2", "stage3.input.stage1.Rs2Value"] }, + Stage3FieldExprPlan { symbol: "stage3.registers.partial.RdWriteValueRs1Value", kind: Stage3FieldExprKind::Add, operands: &["stage3.input.stage1.RdWriteValue", "stage3.registers.term.Rs1Value"] }, + Stage3FieldExprPlan { symbol: "stage3.registers.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers.partial.RdWriteValueRs1Value", "stage3.registers.term.Rs2Value"] }, ]; pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[ Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr", input_openings: "stage3.input.stage1.NextUnexpandedPC|stage3.input.stage1.NextPC|stage3.input.stage1.NextIsVirtual|stage3.input.stage1.NextIsFirstInSequence|stage3.input.stage2.product_virtual.NextIsNoop" }, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 182ff0accb..9e0a3341bc 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -85,15 +85,15 @@ pub const STAGE4_FIELD_CONSTANTS: &[Stage4FieldConstantPlan] = &[ ]; pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[ - Stage4FieldExprPlan { symbol: "stage4.registers_read_write.gamma2", kind: Stage4FieldExprKind::Pow(2), operands: "stage4.registers_read_write.gamma" }, - Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs1Value", kind: Stage4FieldExprKind::Mul, operands: "stage4.registers_read_write.gamma|stage4.input.stage3.registers.Rs1Value" }, - Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs2Value", kind: Stage4FieldExprKind::Mul, operands: "stage4.registers_read_write.gamma2|stage4.input.stage3.registers.Rs2Value" }, - Stage4FieldExprPlan { symbol: "stage4.registers_read_write.partial.RdWriteValueRs1Value", kind: Stage4FieldExprKind::Add, operands: "stage4.input.stage3.registers.RdWriteValue|stage4.registers_read_write.term.Rs1Value" }, - Stage4FieldExprPlan { symbol: "stage4.registers_read_write.claim_expr", kind: Stage4FieldExprKind::Add, operands: "stage4.registers_read_write.partial.RdWriteValueRs1Value|stage4.registers_read_write.term.Rs2Value" }, - Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamVal", kind: Stage4FieldExprKind::Sub, operands: "stage4.input.stage2.RamVal|stage4.input.initial_ram.RamValInit" }, - Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamValFinal", kind: Stage4FieldExprKind::Sub, operands: "stage4.input.stage2.RamValFinal|stage4.input.initial_ram.RamValInit" }, - Stage4FieldExprPlan { symbol: "stage4.ram_val_check.term.RamValFinal", kind: Stage4FieldExprKind::Mul, operands: "stage4.ram_val_check.gamma|stage4.ram_val_check.delta.RamValFinal" }, - Stage4FieldExprPlan { symbol: "stage4.ram_val_check.claim_expr", kind: Stage4FieldExprKind::Add, operands: "stage4.ram_val_check.delta.RamVal|stage4.ram_val_check.term.RamValFinal" }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.gamma2", kind: Stage4FieldExprKind::Pow(2), operands: &["stage4.registers_read_write.gamma"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs1Value", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.gamma", "stage4.input.stage3.registers.Rs1Value"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.term.Rs2Value", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.gamma2", "stage4.input.stage3.registers.Rs2Value"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.partial.RdWriteValueRs1Value", kind: Stage4FieldExprKind::Add, operands: &["stage4.input.stage3.registers.RdWriteValue", "stage4.registers_read_write.term.Rs1Value"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.claim_expr", kind: Stage4FieldExprKind::Add, operands: &["stage4.registers_read_write.partial.RdWriteValueRs1Value", "stage4.registers_read_write.term.Rs2Value"] }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamVal", kind: Stage4FieldExprKind::Sub, operands: &["stage4.input.stage2.RamVal", "stage4.input.initial_ram.RamValInit"] }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamValFinal", kind: Stage4FieldExprKind::Sub, operands: &["stage4.input.stage2.RamValFinal", "stage4.input.initial_ram.RamValInit"] }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.term.RamValFinal", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.gamma", "stage4.ram_val_check.delta.RamValFinal"] }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.claim_expr", kind: Stage4FieldExprKind::Add, operands: &["stage4.ram_val_check.delta.RamVal", "stage4.ram_val_check.term.RamValFinal"] }, ]; pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[ diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index fb30946cca..1fdd30915c 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -85,16 +85,16 @@ pub const STAGE5_FIELD_CONSTANTS: &[Stage5FieldConstantPlan] = &[ ]; pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[ - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.gamma2", kind: Stage5FieldExprKind::Pow(2), operands: "stage5.instruction_read_raf.gamma" }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.LeftLookupOperand", kind: Stage5FieldExprKind::Mul, operands: "stage5.instruction_read_raf.gamma|stage5.input.stage2.instruction.LeftLookupOperand" }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.RightLookupOperand", kind: Stage5FieldExprKind::Mul, operands: "stage5.instruction_read_raf.gamma2|stage5.input.stage2.instruction.RightLookupOperand" }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.partial.LookupOutputLeftOperand", kind: Stage5FieldExprKind::Add, operands: "stage5.input.stage2.instruction.LookupOutput|stage5.instruction_read_raf.term.LeftLookupOperand" }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.claim_expr", kind: Stage5FieldExprKind::Add, operands: "stage5.instruction_read_raf.partial.LookupOutputLeftOperand|stage5.instruction_read_raf.term.RightLookupOperand" }, - Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.gamma2", kind: Stage5FieldExprKind::Pow(2), operands: "stage5.ram_ra_claim_reduction.gamma" }, - Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaReadWrite", kind: Stage5FieldExprKind::Mul, operands: "stage5.ram_ra_claim_reduction.gamma|stage5.input.stage2.ram_read_write.RamRa" }, - Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaValCheck", kind: Stage5FieldExprKind::Mul, operands: "stage5.ram_ra_claim_reduction.gamma2|stage5.input.stage4.ram_val_check.RamRa" }, - Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.partial.RafReadWrite", kind: Stage5FieldExprKind::Add, operands: "stage5.input.stage2.ram_raf.RamRa|stage5.ram_ra_claim_reduction.term.RamRaReadWrite" }, - Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.claim_expr", kind: Stage5FieldExprKind::Add, operands: "stage5.ram_ra_claim_reduction.partial.RafReadWrite|stage5.ram_ra_claim_reduction.term.RamRaValCheck" }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.gamma2", kind: Stage5FieldExprKind::Pow(2), operands: &["stage5.instruction_read_raf.gamma"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.LeftLookupOperand", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.input.stage2.instruction.LeftLookupOperand"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.term.RightLookupOperand", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma2", "stage5.input.stage2.instruction.RightLookupOperand"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.partial.LookupOutputLeftOperand", kind: Stage5FieldExprKind::Add, operands: &["stage5.input.stage2.instruction.LookupOutput", "stage5.instruction_read_raf.term.LeftLookupOperand"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.claim_expr", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.partial.LookupOutputLeftOperand", "stage5.instruction_read_raf.term.RightLookupOperand"] }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.gamma2", kind: Stage5FieldExprKind::Pow(2), operands: &["stage5.ram_ra_claim_reduction.gamma"] }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaReadWrite", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.gamma", "stage5.input.stage2.ram_read_write.RamRa"] }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaValCheck", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.gamma2", "stage5.input.stage4.ram_val_check.RamRa"] }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.partial.RafReadWrite", kind: Stage5FieldExprKind::Add, operands: &["stage5.input.stage2.ram_raf.RamRa", "stage5.ram_ra_claim_reduction.term.RamRaReadWrite"] }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.claim_expr", kind: Stage5FieldExprKind::Add, operands: &["stage5.ram_ra_claim_reduction.partial.RafReadWrite", "stage5.ram_ra_claim_reduction.term.RamRaValCheck"] }, ]; pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[ diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 6166602649..6a891d1432 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -282,69 +282,69 @@ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ ]; macro_rules! stage6_field_expr { - ($symbol:literal, $kind:expr, $operands:literal) => { + ($symbol:literal, $kind:expr, $operands:expr) => { Stage6FieldExprPlan { symbol: $symbol, kind: $kind, operands: $operands } }; } #[rustfmt::skip] pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ - stage6_field_expr!("stage6.booleanity.gamma_sq_0", Stage6FieldExprKind::Pow(0), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_1", Stage6FieldExprKind::Pow(2), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_2", Stage6FieldExprKind::Pow(4), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_3", Stage6FieldExprKind::Pow(6), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_4", Stage6FieldExprKind::Pow(8), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_5", Stage6FieldExprKind::Pow(10), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_6", Stage6FieldExprKind::Pow(12), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_7", Stage6FieldExprKind::Pow(14), "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_sq_8", Stage6FieldExprKind::Pow(16), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_9", Stage6FieldExprKind::Pow(18), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_10", Stage6FieldExprKind::Pow(20), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_11", Stage6FieldExprKind::Pow(22), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_12", Stage6FieldExprKind::Pow(24), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_13", Stage6FieldExprKind::Pow(26), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_14", Stage6FieldExprKind::Pow(28), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_15", Stage6FieldExprKind::Pow(30), "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_sq_16", Stage6FieldExprKind::Pow(32), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_17", Stage6FieldExprKind::Pow(34), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_18", Stage6FieldExprKind::Pow(36), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_19", Stage6FieldExprKind::Pow(38), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_20", Stage6FieldExprKind::Pow(40), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_21", Stage6FieldExprKind::Pow(42), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_22", Stage6FieldExprKind::Pow(44), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_23", Stage6FieldExprKind::Pow(46), "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_sq_24", Stage6FieldExprKind::Pow(48), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_25", Stage6FieldExprKind::Pow(50), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_26", Stage6FieldExprKind::Pow(52), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_27", Stage6FieldExprKind::Pow(54), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_28", Stage6FieldExprKind::Pow(56), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_29", Stage6FieldExprKind::Pow(58), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_30", Stage6FieldExprKind::Pow(60), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_31", Stage6FieldExprKind::Pow(62), "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_sq_32", Stage6FieldExprKind::Pow(64), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_33", Stage6FieldExprKind::Pow(66), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_34", Stage6FieldExprKind::Pow(68), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_35", Stage6FieldExprKind::Pow(70), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_36", Stage6FieldExprKind::Pow(72), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_37", Stage6FieldExprKind::Pow(74), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_sq_38", Stage6FieldExprKind::Pow(76), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_0", Stage6FieldExprKind::Pow(0), "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_pow_1", Stage6FieldExprKind::Pow(1), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_2", Stage6FieldExprKind::Pow(2), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_3", Stage6FieldExprKind::Pow(3), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_4", Stage6FieldExprKind::Pow(4), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_5", Stage6FieldExprKind::Pow(5), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_6", Stage6FieldExprKind::Pow(6), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_7", Stage6FieldExprKind::Pow(7), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_8", Stage6FieldExprKind::Pow(8), "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_pow_9", Stage6FieldExprKind::Pow(9), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_10", Stage6FieldExprKind::Pow(10), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_11", Stage6FieldExprKind::Pow(11), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_12", Stage6FieldExprKind::Pow(12), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_13", Stage6FieldExprKind::Pow(13), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_14", Stage6FieldExprKind::Pow(14), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_15", Stage6FieldExprKind::Pow(15), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_16", Stage6FieldExprKind::Pow(16), "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_pow_17", Stage6FieldExprKind::Pow(17), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_18", Stage6FieldExprKind::Pow(18), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_19", Stage6FieldExprKind::Pow(19), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_20", Stage6FieldExprKind::Pow(20), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_21", Stage6FieldExprKind::Pow(21), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_22", Stage6FieldExprKind::Pow(22), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_23", Stage6FieldExprKind::Pow(23), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_24", Stage6FieldExprKind::Pow(24), "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_pow_25", Stage6FieldExprKind::Pow(25), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_26", Stage6FieldExprKind::Pow(26), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_27", Stage6FieldExprKind::Pow(27), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_28", Stage6FieldExprKind::Pow(28), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_29", Stage6FieldExprKind::Pow(29), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_30", Stage6FieldExprKind::Pow(30), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_31", Stage6FieldExprKind::Pow(31), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_32", Stage6FieldExprKind::Pow(32), "stage6.booleanity.gamma"), - stage6_field_expr!("stage6.booleanity.gamma_pow_33", Stage6FieldExprKind::Pow(33), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_34", Stage6FieldExprKind::Pow(34), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_35", Stage6FieldExprKind::Pow(35), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_36", Stage6FieldExprKind::Pow(36), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_37", Stage6FieldExprKind::Pow(37), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.booleanity.gamma_pow_38", Stage6FieldExprKind::Pow(38), "stage6.booleanity.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term1.stage_gamma_pow|stage6.input.stage1.Imm"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term2.stage_gamma_pow|stage6.input.stage1.OpFlagAddOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term3.stage_gamma_pow|stage6.input.stage1.OpFlagSubtractOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term4.stage_gamma_pow|stage6.input.stage1.OpFlagMultiplyOperands"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", Stage6FieldExprKind::Pow(5), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term5.stage_gamma_pow|stage6.input.stage1.OpFlagLoad"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", Stage6FieldExprKind::Pow(6), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term6.stage_gamma_pow|stage6.input.stage1.OpFlagStore"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", Stage6FieldExprKind::Pow(7), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term7.stage_gamma_pow|stage6.input.stage1.OpFlagJump"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", Stage6FieldExprKind::Pow(8), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term8.stage_gamma_pow|stage6.input.stage1.OpFlagWriteLookupOutputToRD"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", Stage6FieldExprKind::Pow(9), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term9.stage_gamma_pow|stage6.input.stage1.OpFlagVirtualInstruction"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", Stage6FieldExprKind::Pow(10), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term10.stage_gamma_pow|stage6.input.stage1.OpFlagAssert"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", Stage6FieldExprKind::Pow(11), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term11.stage_gamma_pow|stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", Stage6FieldExprKind::Pow(12), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term12.stage_gamma_pow|stage6.input.stage1.OpFlagAdvice"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", Stage6FieldExprKind::Pow(13), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term13.stage_gamma_pow|stage6.input.stage1.OpFlagIsCompressed"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", Stage6FieldExprKind::Pow(14), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term14.stage_gamma_pow|stage6.input.stage1.OpFlagIsFirstInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", Stage6FieldExprKind::Pow(15), "stage6.bytecode_read_raf.stage1_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term15.stage_gamma_pow|stage6.input.stage1.OpFlagIsLastInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term16.gamma_pow|stage6.input.stage2.OpFlagJump"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term17.stage_gamma_pow|stage6.input.stage2.InstructionFlagBranch"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term17.gamma_pow|stage6.bytecode_read_raf.claim.term17.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term18.stage_gamma_pow|stage6.input.stage2.OpFlagWriteLookupOutputToRD"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term18.gamma_pow|stage6.bytecode_read_raf.claim.term18.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.stage2_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term19.stage_gamma_pow|stage6.input.stage2.OpFlagVirtualInstruction"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term19.gamma_pow|stage6.bytecode_read_raf.claim.term19.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term20.gamma_pow|stage6.input.stage3.instruction_input.Imm"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term21.stage_gamma_pow|stage6.input.stage3.spartan_shift.UnexpandedPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term21.gamma_pow|stage6.bytecode_read_raf.claim.term21.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term22.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term22.gamma_pow|stage6.bytecode_read_raf.claim.term22.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term23.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term23.gamma_pow|stage6.bytecode_read_raf.claim.term23.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term24.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term24.gamma_pow|stage6.bytecode_read_raf.claim.term24.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", Stage6FieldExprKind::Pow(5), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term25.stage_gamma_pow|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term25.gamma_pow|stage6.bytecode_read_raf.claim.term25.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", Stage6FieldExprKind::Pow(6), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term26.stage_gamma_pow|stage6.input.stage3.spartan_shift.InstructionFlagIsNoop"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term26.gamma_pow|stage6.bytecode_read_raf.claim.term26.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", Stage6FieldExprKind::Pow(7), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term27.stage_gamma_pow|stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term27.gamma_pow|stage6.bytecode_read_raf.claim.term27.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", Stage6FieldExprKind::Pow(8), "stage6.bytecode_read_raf.stage3_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term28.stage_gamma_pow|stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term28.gamma_pow|stage6.bytecode_read_raf.claim.term28.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term29.gamma_pow|stage6.input.stage4.RdWa"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.stage4_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term30.stage_gamma_pow|stage6.input.stage4.Rs1Ra"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term30.gamma_pow|stage6.bytecode_read_raf.claim.term30.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.stage4_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term31.stage_gamma_pow|stage6.input.stage4.Rs2Ra"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term31.gamma_pow|stage6.bytecode_read_raf.claim.term31.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term32.gamma_pow|stage6.input.stage5.registers_val_evaluation.RdWa"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term33.stage_gamma_pow|stage6.input.stage5.InstructionRafFlag"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term33.gamma_pow|stage6.bytecode_read_raf.claim.term33.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term34.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_0"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term34.gamma_pow|stage6.bytecode_read_raf.claim.term34.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term35.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_1"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term35.gamma_pow|stage6.bytecode_read_raf.claim.term35.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term36.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_2"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term36.gamma_pow|stage6.bytecode_read_raf.claim.term36.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", Stage6FieldExprKind::Pow(5), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term37.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_3"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term37.gamma_pow|stage6.bytecode_read_raf.claim.term37.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", Stage6FieldExprKind::Pow(6), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term38.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_4"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term38.gamma_pow|stage6.bytecode_read_raf.claim.term38.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", Stage6FieldExprKind::Pow(7), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term39.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_5"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term39.gamma_pow|stage6.bytecode_read_raf.claim.term39.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", Stage6FieldExprKind::Pow(8), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term40.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_6"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term40.gamma_pow|stage6.bytecode_read_raf.claim.term40.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", Stage6FieldExprKind::Pow(9), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term41.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_7"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term41.gamma_pow|stage6.bytecode_read_raf.claim.term41.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", Stage6FieldExprKind::Pow(10), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term42.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_8"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term42.gamma_pow|stage6.bytecode_read_raf.claim.term42.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", Stage6FieldExprKind::Pow(11), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term43.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_9"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term43.gamma_pow|stage6.bytecode_read_raf.claim.term43.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", Stage6FieldExprKind::Pow(12), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term44.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_10"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term44.gamma_pow|stage6.bytecode_read_raf.claim.term44.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", Stage6FieldExprKind::Pow(13), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term45.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_11"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term45.gamma_pow|stage6.bytecode_read_raf.claim.term45.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", Stage6FieldExprKind::Pow(14), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term46.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_12"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term46.gamma_pow|stage6.bytecode_read_raf.claim.term46.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", Stage6FieldExprKind::Pow(15), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term47.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_13"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term47.gamma_pow|stage6.bytecode_read_raf.claim.term47.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", Stage6FieldExprKind::Pow(16), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term48.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_14"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term48.gamma_pow|stage6.bytecode_read_raf.claim.term48.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", Stage6FieldExprKind::Pow(17), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term49.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_15"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term49.gamma_pow|stage6.bytecode_read_raf.claim.term49.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", Stage6FieldExprKind::Pow(18), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term50.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_16"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term50.gamma_pow|stage6.bytecode_read_raf.claim.term50.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", Stage6FieldExprKind::Pow(19), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term51.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_17"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term51.gamma_pow|stage6.bytecode_read_raf.claim.term51.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", Stage6FieldExprKind::Pow(20), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term52.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_18"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term52.gamma_pow|stage6.bytecode_read_raf.claim.term52.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", Stage6FieldExprKind::Pow(21), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term53.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_19"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term53.gamma_pow|stage6.bytecode_read_raf.claim.term53.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", Stage6FieldExprKind::Pow(22), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term54.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_20"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term54.gamma_pow|stage6.bytecode_read_raf.claim.term54.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", Stage6FieldExprKind::Pow(23), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term55.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_21"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term55.gamma_pow|stage6.bytecode_read_raf.claim.term55.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", Stage6FieldExprKind::Pow(24), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term56.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_22"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term56.gamma_pow|stage6.bytecode_read_raf.claim.term56.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", Stage6FieldExprKind::Pow(25), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term57.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_23"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term57.gamma_pow|stage6.bytecode_read_raf.claim.term57.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", Stage6FieldExprKind::Pow(26), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term58.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_24"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term58.gamma_pow|stage6.bytecode_read_raf.claim.term58.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", Stage6FieldExprKind::Pow(27), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term59.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_25"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term59.gamma_pow|stage6.bytecode_read_raf.claim.term59.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", Stage6FieldExprKind::Pow(28), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term60.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_26"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term60.gamma_pow|stage6.bytecode_read_raf.claim.term60.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", Stage6FieldExprKind::Pow(29), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term61.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_27"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term61.gamma_pow|stage6.bytecode_read_raf.claim.term61.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", Stage6FieldExprKind::Pow(30), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term62.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_28"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term62.gamma_pow|stage6.bytecode_read_raf.claim.term62.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", Stage6FieldExprKind::Pow(31), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term63.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_29"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term63.gamma_pow|stage6.bytecode_read_raf.claim.term63.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", Stage6FieldExprKind::Pow(32), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term64.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_30"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term64.gamma_pow|stage6.bytecode_read_raf.claim.term64.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", Stage6FieldExprKind::Pow(33), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term65.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_31"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term65.gamma_pow|stage6.bytecode_read_raf.claim.term65.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", Stage6FieldExprKind::Pow(34), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term66.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_32"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term66.gamma_pow|stage6.bytecode_read_raf.claim.term66.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", Stage6FieldExprKind::Pow(35), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term67.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_33"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term67.gamma_pow|stage6.bytecode_read_raf.claim.term67.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", Stage6FieldExprKind::Pow(36), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term68.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_34"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term68.gamma_pow|stage6.bytecode_read_raf.claim.term68.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", Stage6FieldExprKind::Pow(37), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term69.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_35"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term69.gamma_pow|stage6.bytecode_read_raf.claim.term69.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", Stage6FieldExprKind::Pow(38), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term70.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_36"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term70.gamma_pow|stage6.bytecode_read_raf.claim.term70.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", Stage6FieldExprKind::Pow(39), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term71.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_37"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term71.gamma_pow|stage6.bytecode_read_raf.claim.term71.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", Stage6FieldExprKind::Pow(40), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term72.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_38"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term72.gamma_pow|stage6.bytecode_read_raf.claim.term72.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", Stage6FieldExprKind::Pow(41), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term73.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_39"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term73.gamma_pow|stage6.bytecode_read_raf.claim.term73.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", Stage6FieldExprKind::Pow(42), "stage6.bytecode_read_raf.stage5_gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term74.stage_gamma_pow|stage6.input.stage5.LookupTableFlag_40"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term74.gamma_pow|stage6.bytecode_read_raf.claim.term74.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_pow", Stage6FieldExprKind::Pow(5), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term75.gamma_pow|stage6.input.stage1.PC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_pow", Stage6FieldExprKind::Pow(6), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_term", Stage6FieldExprKind::Mul, "stage6.bytecode_read_raf.claim.term76.gamma_pow|stage6.input.stage3.spartan_shift.PC"), stage6_field_expr!("stage6.bytecode_read_raf.claim.entry_constant", Stage6FieldExprKind::Pow(7), "stage6.bytecode_read_raf.gamma"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial0", Stage6FieldExprKind::Add, "stage6.input.stage1.UnexpandedPC|stage6.bytecode_read_raf.claim.term1.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial1", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial0|stage6.bytecode_read_raf.claim.term2.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial2", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial1|stage6.bytecode_read_raf.claim.term3.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial3", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial2|stage6.bytecode_read_raf.claim.term4.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial4", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial3|stage6.bytecode_read_raf.claim.term5.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial5", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial4|stage6.bytecode_read_raf.claim.term6.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial6", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial5|stage6.bytecode_read_raf.claim.term7.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial7", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial6|stage6.bytecode_read_raf.claim.term8.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial8", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial7|stage6.bytecode_read_raf.claim.term9.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial9", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial8|stage6.bytecode_read_raf.claim.term10.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial10", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial9|stage6.bytecode_read_raf.claim.term11.stage_gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial11", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial10|stage6.bytecode_read_raf.claim.term12.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial12", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial11|stage6.bytecode_read_raf.claim.term13.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial13", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial12|stage6.bytecode_read_raf.claim.term14.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial14", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial13|stage6.bytecode_read_raf.claim.term15.stage_gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial15", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial14|stage6.bytecode_read_raf.claim.term16.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial16", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial15|stage6.bytecode_read_raf.claim.term17.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial17", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial16|stage6.bytecode_read_raf.claim.term18.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial18", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial17|stage6.bytecode_read_raf.claim.term19.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial19", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial18|stage6.bytecode_read_raf.claim.term20.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial20", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial19|stage6.bytecode_read_raf.claim.term21.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial21", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial20|stage6.bytecode_read_raf.claim.term22.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial22", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial21|stage6.bytecode_read_raf.claim.term23.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial23", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial22|stage6.bytecode_read_raf.claim.term24.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial24", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial23|stage6.bytecode_read_raf.claim.term25.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial25", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial24|stage6.bytecode_read_raf.claim.term26.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial26", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial25|stage6.bytecode_read_raf.claim.term27.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial27", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial26|stage6.bytecode_read_raf.claim.term28.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial28", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial27|stage6.bytecode_read_raf.claim.term29.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial29", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial28|stage6.bytecode_read_raf.claim.term30.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial30", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial29|stage6.bytecode_read_raf.claim.term31.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial31", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial30|stage6.bytecode_read_raf.claim.term32.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial32", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial31|stage6.bytecode_read_raf.claim.term33.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial33", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial32|stage6.bytecode_read_raf.claim.term34.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial34", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial33|stage6.bytecode_read_raf.claim.term35.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial35", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial34|stage6.bytecode_read_raf.claim.term36.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial36", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial35|stage6.bytecode_read_raf.claim.term37.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial37", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial36|stage6.bytecode_read_raf.claim.term38.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial38", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial37|stage6.bytecode_read_raf.claim.term39.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial39", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial38|stage6.bytecode_read_raf.claim.term40.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial40", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial39|stage6.bytecode_read_raf.claim.term41.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial41", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial40|stage6.bytecode_read_raf.claim.term42.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial42", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial41|stage6.bytecode_read_raf.claim.term43.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial43", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial42|stage6.bytecode_read_raf.claim.term44.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial44", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial43|stage6.bytecode_read_raf.claim.term45.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial45", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial44|stage6.bytecode_read_raf.claim.term46.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial46", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial45|stage6.bytecode_read_raf.claim.term47.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial47", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial46|stage6.bytecode_read_raf.claim.term48.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial48", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial47|stage6.bytecode_read_raf.claim.term49.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial49", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial48|stage6.bytecode_read_raf.claim.term50.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial50", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial49|stage6.bytecode_read_raf.claim.term51.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial51", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial50|stage6.bytecode_read_raf.claim.term52.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial52", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial51|stage6.bytecode_read_raf.claim.term53.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial53", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial52|stage6.bytecode_read_raf.claim.term54.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial54", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial53|stage6.bytecode_read_raf.claim.term55.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial55", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial54|stage6.bytecode_read_raf.claim.term56.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial56", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial55|stage6.bytecode_read_raf.claim.term57.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial57", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial56|stage6.bytecode_read_raf.claim.term58.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial58", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial57|stage6.bytecode_read_raf.claim.term59.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial59", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial58|stage6.bytecode_read_raf.claim.term60.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial60", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial59|stage6.bytecode_read_raf.claim.term61.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial61", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial60|stage6.bytecode_read_raf.claim.term62.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial62", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial61|stage6.bytecode_read_raf.claim.term63.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial63", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial62|stage6.bytecode_read_raf.claim.term64.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial64", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial63|stage6.bytecode_read_raf.claim.term65.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial65", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial64|stage6.bytecode_read_raf.claim.term66.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial66", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial65|stage6.bytecode_read_raf.claim.term67.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial67", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial66|stage6.bytecode_read_raf.claim.term68.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial68", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial67|stage6.bytecode_read_raf.claim.term69.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial69", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial68|stage6.bytecode_read_raf.claim.term70.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial70", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial69|stage6.bytecode_read_raf.claim.term71.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial71", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial70|stage6.bytecode_read_raf.claim.term72.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial72", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial71|stage6.bytecode_read_raf.claim.term73.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial73", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial72|stage6.bytecode_read_raf.claim.term74.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial74", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial73|stage6.bytecode_read_raf.claim.term75.gamma_term"), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial75", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial74|stage6.bytecode_read_raf.claim.term76.gamma_term"), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial76", Stage6FieldExprKind::Add, "stage6.bytecode_read_raf.claim_expr.partial75|stage6.bytecode_read_raf.claim.entry_constant"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term1.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_1"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term2.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_2"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term3.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_3"), - stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term4.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_4"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term5.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_5"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term6.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_6"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), "stage6.instruction_ra_virtual.gamma"), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, "stage6.instruction_ra_virtual.claim.term7.gamma_pow|stage6.input.stage5.instruction_read_raf.InstructionRa_7"), - stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, "stage6.input.stage5.instruction_read_raf.InstructionRa_0|stage6.instruction_ra_virtual.claim.term1.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial0|stage6.instruction_ra_virtual.claim.term2.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial1|stage6.instruction_ra_virtual.claim.term3.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial2|stage6.instruction_ra_virtual.claim.term4.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial3|stage6.instruction_ra_virtual.claim.term5.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial4|stage6.instruction_ra_virtual.claim.term6.gamma_term"), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, "stage6.instruction_ra_virtual.claim_expr.partial5|stage6.instruction_ra_virtual.claim.term7.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), "stage6.inc_claim_reduction.gamma"), - stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow|stage6.input.stage4.ram_val_check.RamInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), "stage6.inc_claim_reduction.gamma"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow|stage6.input.stage4.registers_read_write.RdInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), "stage6.inc_claim_reduction.gamma"), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow|stage6.input.stage5.registers_val_evaluation.RdInc"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, "stage6.input.stage2.ram_read_write.RamInc|stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, "stage6.inc_claim_reduction.claim_expr.partial0|stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, "stage6.inc_claim_reduction.claim_expr.partial1|stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"), + stage6_field_expr!("stage6.booleanity.gamma_sq_0", Stage6FieldExprKind::Pow(0), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_1", Stage6FieldExprKind::Pow(2), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_2", Stage6FieldExprKind::Pow(4), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_3", Stage6FieldExprKind::Pow(6), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_4", Stage6FieldExprKind::Pow(8), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_5", Stage6FieldExprKind::Pow(10), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_6", Stage6FieldExprKind::Pow(12), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_7", Stage6FieldExprKind::Pow(14), &["stage6.booleanity.gamma"]), + stage6_field_expr!("stage6.booleanity.gamma_sq_8", Stage6FieldExprKind::Pow(16), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_9", Stage6FieldExprKind::Pow(18), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_10", Stage6FieldExprKind::Pow(20), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_11", Stage6FieldExprKind::Pow(22), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_12", Stage6FieldExprKind::Pow(24), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_13", Stage6FieldExprKind::Pow(26), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_14", Stage6FieldExprKind::Pow(28), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_15", Stage6FieldExprKind::Pow(30), &["stage6.booleanity.gamma"]), + stage6_field_expr!("stage6.booleanity.gamma_sq_16", Stage6FieldExprKind::Pow(32), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_17", Stage6FieldExprKind::Pow(34), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_18", Stage6FieldExprKind::Pow(36), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_19", Stage6FieldExprKind::Pow(38), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_20", Stage6FieldExprKind::Pow(40), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_21", Stage6FieldExprKind::Pow(42), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_22", Stage6FieldExprKind::Pow(44), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_23", Stage6FieldExprKind::Pow(46), &["stage6.booleanity.gamma"]), + stage6_field_expr!("stage6.booleanity.gamma_sq_24", Stage6FieldExprKind::Pow(48), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_25", Stage6FieldExprKind::Pow(50), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_26", Stage6FieldExprKind::Pow(52), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_27", Stage6FieldExprKind::Pow(54), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_28", Stage6FieldExprKind::Pow(56), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_29", Stage6FieldExprKind::Pow(58), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_30", Stage6FieldExprKind::Pow(60), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_31", Stage6FieldExprKind::Pow(62), &["stage6.booleanity.gamma"]), + stage6_field_expr!("stage6.booleanity.gamma_sq_32", Stage6FieldExprKind::Pow(64), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_33", Stage6FieldExprKind::Pow(66), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_34", Stage6FieldExprKind::Pow(68), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_35", Stage6FieldExprKind::Pow(70), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_36", Stage6FieldExprKind::Pow(72), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_37", Stage6FieldExprKind::Pow(74), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_38", Stage6FieldExprKind::Pow(76), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_0", Stage6FieldExprKind::Pow(0), &["stage6.booleanity.gamma"]), + stage6_field_expr!("stage6.booleanity.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_8", Stage6FieldExprKind::Pow(8), &["stage6.booleanity.gamma"]), + stage6_field_expr!("stage6.booleanity.gamma_pow_9", Stage6FieldExprKind::Pow(9), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_10", Stage6FieldExprKind::Pow(10), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_11", Stage6FieldExprKind::Pow(11), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_12", Stage6FieldExprKind::Pow(12), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_13", Stage6FieldExprKind::Pow(13), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_14", Stage6FieldExprKind::Pow(14), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_15", Stage6FieldExprKind::Pow(15), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_16", Stage6FieldExprKind::Pow(16), &["stage6.booleanity.gamma"]), + stage6_field_expr!("stage6.booleanity.gamma_pow_17", Stage6FieldExprKind::Pow(17), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_18", Stage6FieldExprKind::Pow(18), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_19", Stage6FieldExprKind::Pow(19), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_20", Stage6FieldExprKind::Pow(20), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_21", Stage6FieldExprKind::Pow(21), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_22", Stage6FieldExprKind::Pow(22), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_23", Stage6FieldExprKind::Pow(23), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_24", Stage6FieldExprKind::Pow(24), &["stage6.booleanity.gamma"]), + stage6_field_expr!("stage6.booleanity.gamma_pow_25", Stage6FieldExprKind::Pow(25), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_26", Stage6FieldExprKind::Pow(26), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_27", Stage6FieldExprKind::Pow(27), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_28", Stage6FieldExprKind::Pow(28), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_29", Stage6FieldExprKind::Pow(29), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_30", Stage6FieldExprKind::Pow(30), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_31", Stage6FieldExprKind::Pow(31), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_32", Stage6FieldExprKind::Pow(32), &["stage6.booleanity.gamma"]), + stage6_field_expr!("stage6.booleanity.gamma_pow_33", Stage6FieldExprKind::Pow(33), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_34", Stage6FieldExprKind::Pow(34), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_35", Stage6FieldExprKind::Pow(35), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_36", Stage6FieldExprKind::Pow(36), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_37", Stage6FieldExprKind::Pow(37), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_38", Stage6FieldExprKind::Pow(38), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", "stage6.input.stage1.Imm"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", "stage6.input.stage1.OpFlagAddOperands"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", "stage6.input.stage1.OpFlagSubtractOperands"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", "stage6.input.stage1.OpFlagMultiplyOperands"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", "stage6.input.stage1.OpFlagLoad"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", "stage6.input.stage1.OpFlagStore"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", "stage6.input.stage1.OpFlagJump"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", "stage6.input.stage1.OpFlagWriteLookupOutputToRD"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", "stage6.input.stage1.OpFlagVirtualInstruction"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", "stage6.input.stage1.OpFlagAssert"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", "stage6.input.stage1.OpFlagAdvice"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", "stage6.input.stage1.OpFlagIsCompressed"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", "stage6.input.stage1.OpFlagIsFirstInSequence"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", "stage6.input.stage1.OpFlagIsLastInSequence"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term16.gamma_pow", "stage6.input.stage2.OpFlagJump"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", "stage6.input.stage2.InstructionFlagBranch"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.gamma_pow", "stage6.bytecode_read_raf.claim.term17.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", "stage6.input.stage2.OpFlagWriteLookupOutputToRD"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.gamma_pow", "stage6.bytecode_read_raf.claim.term18.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", "stage6.input.stage2.OpFlagVirtualInstruction"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.gamma_pow", "stage6.bytecode_read_raf.claim.term19.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term20.gamma_pow", "stage6.input.stage3.instruction_input.Imm"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", "stage6.input.stage3.spartan_shift.UnexpandedPC"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.gamma_pow", "stage6.bytecode_read_raf.claim.term21.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.gamma_pow", "stage6.bytecode_read_raf.claim.term22.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.gamma_pow", "stage6.bytecode_read_raf.claim.term23.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.gamma_pow", "stage6.bytecode_read_raf.claim.term24.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.gamma_pow", "stage6.bytecode_read_raf.claim.term25.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.gamma_pow", "stage6.bytecode_read_raf.claim.term26.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.gamma_pow", "stage6.bytecode_read_raf.claim.term27.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.gamma_pow", "stage6.bytecode_read_raf.claim.term28.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term29.gamma_pow", "stage6.input.stage4.RdWa"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", "stage6.input.stage4.Rs1Ra"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.gamma_pow", "stage6.bytecode_read_raf.claim.term30.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", "stage6.input.stage4.Rs2Ra"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.gamma_pow", "stage6.bytecode_read_raf.claim.term31.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term32.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdWa"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", "stage6.input.stage5.InstructionRafFlag"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.gamma_pow", "stage6.bytecode_read_raf.claim.term33.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_0"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.gamma_pow", "stage6.bytecode_read_raf.claim.term34.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_1"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.gamma_pow", "stage6.bytecode_read_raf.claim.term35.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_2"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.gamma_pow", "stage6.bytecode_read_raf.claim.term36.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_3"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.gamma_pow", "stage6.bytecode_read_raf.claim.term37.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_4"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.gamma_pow", "stage6.bytecode_read_raf.claim.term38.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_5"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.gamma_pow", "stage6.bytecode_read_raf.claim.term39.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_6"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.gamma_pow", "stage6.bytecode_read_raf.claim.term40.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_7"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.gamma_pow", "stage6.bytecode_read_raf.claim.term41.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_8"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.gamma_pow", "stage6.bytecode_read_raf.claim.term42.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_9"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.gamma_pow", "stage6.bytecode_read_raf.claim.term43.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_10"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.gamma_pow", "stage6.bytecode_read_raf.claim.term44.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_11"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.gamma_pow", "stage6.bytecode_read_raf.claim.term45.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_12"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.gamma_pow", "stage6.bytecode_read_raf.claim.term46.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_13"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.gamma_pow", "stage6.bytecode_read_raf.claim.term47.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", Stage6FieldExprKind::Pow(16), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_14"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.gamma_pow", "stage6.bytecode_read_raf.claim.term48.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", Stage6FieldExprKind::Pow(17), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_15"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.gamma_pow", "stage6.bytecode_read_raf.claim.term49.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", Stage6FieldExprKind::Pow(18), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_16"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.gamma_pow", "stage6.bytecode_read_raf.claim.term50.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", Stage6FieldExprKind::Pow(19), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_17"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.gamma_pow", "stage6.bytecode_read_raf.claim.term51.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", Stage6FieldExprKind::Pow(20), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_18"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.gamma_pow", "stage6.bytecode_read_raf.claim.term52.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", Stage6FieldExprKind::Pow(21), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_19"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.gamma_pow", "stage6.bytecode_read_raf.claim.term53.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", Stage6FieldExprKind::Pow(22), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_20"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.gamma_pow", "stage6.bytecode_read_raf.claim.term54.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", Stage6FieldExprKind::Pow(23), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_21"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.gamma_pow", "stage6.bytecode_read_raf.claim.term55.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", Stage6FieldExprKind::Pow(24), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_22"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.gamma_pow", "stage6.bytecode_read_raf.claim.term56.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", Stage6FieldExprKind::Pow(25), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_23"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.gamma_pow", "stage6.bytecode_read_raf.claim.term57.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", Stage6FieldExprKind::Pow(26), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_24"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.gamma_pow", "stage6.bytecode_read_raf.claim.term58.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", Stage6FieldExprKind::Pow(27), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_25"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.gamma_pow", "stage6.bytecode_read_raf.claim.term59.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", Stage6FieldExprKind::Pow(28), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_26"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.gamma_pow", "stage6.bytecode_read_raf.claim.term60.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", Stage6FieldExprKind::Pow(29), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_27"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.gamma_pow", "stage6.bytecode_read_raf.claim.term61.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", Stage6FieldExprKind::Pow(30), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_28"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.gamma_pow", "stage6.bytecode_read_raf.claim.term62.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", Stage6FieldExprKind::Pow(31), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_29"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.gamma_pow", "stage6.bytecode_read_raf.claim.term63.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", Stage6FieldExprKind::Pow(32), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_30"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.gamma_pow", "stage6.bytecode_read_raf.claim.term64.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", Stage6FieldExprKind::Pow(33), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_31"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.gamma_pow", "stage6.bytecode_read_raf.claim.term65.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", Stage6FieldExprKind::Pow(34), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_32"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.gamma_pow", "stage6.bytecode_read_raf.claim.term66.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", Stage6FieldExprKind::Pow(35), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_33"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.gamma_pow", "stage6.bytecode_read_raf.claim.term67.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", Stage6FieldExprKind::Pow(36), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_34"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.gamma_pow", "stage6.bytecode_read_raf.claim.term68.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", Stage6FieldExprKind::Pow(37), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_35"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.gamma_pow", "stage6.bytecode_read_raf.claim.term69.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", Stage6FieldExprKind::Pow(38), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_36"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.gamma_pow", "stage6.bytecode_read_raf.claim.term70.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", Stage6FieldExprKind::Pow(39), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_37"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.gamma_pow", "stage6.bytecode_read_raf.claim.term71.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", Stage6FieldExprKind::Pow(40), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_38"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.gamma_pow", "stage6.bytecode_read_raf.claim.term72.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", Stage6FieldExprKind::Pow(41), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_39"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.gamma_pow", "stage6.bytecode_read_raf.claim.term73.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", Stage6FieldExprKind::Pow(42), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_40"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.gamma_pow", "stage6.bytecode_read_raf.claim.term74.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term75.gamma_pow", "stage6.input.stage1.PC"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term76.gamma_pow", "stage6.input.stage3.spartan_shift.PC"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.entry_constant", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage1.UnexpandedPC", "stage6.bytecode_read_raf.claim.term1.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial0", "stage6.bytecode_read_raf.claim.term2.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial1", "stage6.bytecode_read_raf.claim.term3.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial2", "stage6.bytecode_read_raf.claim.term4.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial3", "stage6.bytecode_read_raf.claim.term5.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial4", "stage6.bytecode_read_raf.claim.term6.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial5", "stage6.bytecode_read_raf.claim.term7.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial7", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial6", "stage6.bytecode_read_raf.claim.term8.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial8", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial7", "stage6.bytecode_read_raf.claim.term9.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial9", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial8", "stage6.bytecode_read_raf.claim.term10.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial10", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial9", "stage6.bytecode_read_raf.claim.term11.stage_gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial11", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial10", "stage6.bytecode_read_raf.claim.term12.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial12", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial11", "stage6.bytecode_read_raf.claim.term13.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial13", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial12", "stage6.bytecode_read_raf.claim.term14.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial14", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial13", "stage6.bytecode_read_raf.claim.term15.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial15", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial14", "stage6.bytecode_read_raf.claim.term16.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial16", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial15", "stage6.bytecode_read_raf.claim.term17.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial17", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial16", "stage6.bytecode_read_raf.claim.term18.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial18", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial17", "stage6.bytecode_read_raf.claim.term19.gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial19", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial18", "stage6.bytecode_read_raf.claim.term20.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial20", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial19", "stage6.bytecode_read_raf.claim.term21.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial21", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial20", "stage6.bytecode_read_raf.claim.term22.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial22", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial21", "stage6.bytecode_read_raf.claim.term23.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial23", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial22", "stage6.bytecode_read_raf.claim.term24.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial24", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial23", "stage6.bytecode_read_raf.claim.term25.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial25", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial24", "stage6.bytecode_read_raf.claim.term26.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial26", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial25", "stage6.bytecode_read_raf.claim.term27.gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial27", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial26", "stage6.bytecode_read_raf.claim.term28.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial28", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial27", "stage6.bytecode_read_raf.claim.term29.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial29", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial28", "stage6.bytecode_read_raf.claim.term30.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial30", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial29", "stage6.bytecode_read_raf.claim.term31.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial31", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial30", "stage6.bytecode_read_raf.claim.term32.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial32", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial31", "stage6.bytecode_read_raf.claim.term33.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial33", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial32", "stage6.bytecode_read_raf.claim.term34.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial34", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial33", "stage6.bytecode_read_raf.claim.term35.gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial35", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial34", "stage6.bytecode_read_raf.claim.term36.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial36", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial35", "stage6.bytecode_read_raf.claim.term37.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial37", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial36", "stage6.bytecode_read_raf.claim.term38.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial38", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial37", "stage6.bytecode_read_raf.claim.term39.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial39", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial38", "stage6.bytecode_read_raf.claim.term40.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial40", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial39", "stage6.bytecode_read_raf.claim.term41.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial41", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial40", "stage6.bytecode_read_raf.claim.term42.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial42", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial41", "stage6.bytecode_read_raf.claim.term43.gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial43", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial42", "stage6.bytecode_read_raf.claim.term44.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial44", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial43", "stage6.bytecode_read_raf.claim.term45.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial45", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial44", "stage6.bytecode_read_raf.claim.term46.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial46", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial45", "stage6.bytecode_read_raf.claim.term47.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial47", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial46", "stage6.bytecode_read_raf.claim.term48.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial48", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial47", "stage6.bytecode_read_raf.claim.term49.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial49", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial48", "stage6.bytecode_read_raf.claim.term50.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial50", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial49", "stage6.bytecode_read_raf.claim.term51.gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial51", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial50", "stage6.bytecode_read_raf.claim.term52.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial52", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial51", "stage6.bytecode_read_raf.claim.term53.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial53", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial52", "stage6.bytecode_read_raf.claim.term54.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial54", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial53", "stage6.bytecode_read_raf.claim.term55.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial55", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial54", "stage6.bytecode_read_raf.claim.term56.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial56", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial55", "stage6.bytecode_read_raf.claim.term57.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial57", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial56", "stage6.bytecode_read_raf.claim.term58.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial58", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial57", "stage6.bytecode_read_raf.claim.term59.gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial59", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial58", "stage6.bytecode_read_raf.claim.term60.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial60", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial59", "stage6.bytecode_read_raf.claim.term61.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial61", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial60", "stage6.bytecode_read_raf.claim.term62.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial62", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial61", "stage6.bytecode_read_raf.claim.term63.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial63", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial62", "stage6.bytecode_read_raf.claim.term64.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial64", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial63", "stage6.bytecode_read_raf.claim.term65.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial65", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial64", "stage6.bytecode_read_raf.claim.term66.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial66", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial65", "stage6.bytecode_read_raf.claim.term67.gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial67", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial66", "stage6.bytecode_read_raf.claim.term68.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial68", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial67", "stage6.bytecode_read_raf.claim.term69.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial69", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial68", "stage6.bytecode_read_raf.claim.term70.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial70", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial69", "stage6.bytecode_read_raf.claim.term71.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial71", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial70", "stage6.bytecode_read_raf.claim.term72.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial72", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial71", "stage6.bytecode_read_raf.claim.term73.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial73", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial72", "stage6.bytecode_read_raf.claim.term74.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial74", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial73", "stage6.bytecode_read_raf.claim.term75.gamma_term"]), + stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial75", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial74", "stage6.bytecode_read_raf.claim.term76.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial76", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial75", "stage6.bytecode_read_raf.claim.entry_constant"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term1.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_1"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term2.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_2"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term3.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_3"]), + stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), + stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), + stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index bd460c36c7..9d88207e1b 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -153,57 +153,57 @@ pub const STAGE7_FIELD_CONSTANTS: &[Stage7FieldConstantPlan] = &[ ]; macro_rules! stage7_field_expr { - ($symbol:literal, $kind:expr, $operands:literal) => { + ($symbol:literal, $kind:expr, $operands:expr) => { Stage7FieldExprPlan { symbol: $symbol, kind: $kind, operands: $operands } }; } #[rustfmt::skip] pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[ - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", Stage7FieldExprKind::Pow(1), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", Stage7FieldExprKind::Pow(2), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", Stage7FieldExprKind::Pow(3), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", Stage7FieldExprKind::Pow(4), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_1"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", Stage7FieldExprKind::Pow(5), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", Stage7FieldExprKind::Pow(6), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", Stage7FieldExprKind::Pow(7), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", Stage7FieldExprKind::Pow(8), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", Stage7FieldExprKind::Pow(9), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", Stage7FieldExprKind::Pow(10), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", Stage7FieldExprKind::Pow(11), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", Stage7FieldExprKind::Pow(12), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", Stage7FieldExprKind::Pow(13), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_4"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", Stage7FieldExprKind::Pow(14), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", Stage7FieldExprKind::Pow(15), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", Stage7FieldExprKind::Pow(16), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_5"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", Stage7FieldExprKind::Pow(17), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", Stage7FieldExprKind::Pow(18), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", Stage7FieldExprKind::Pow(19), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_6"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", Stage7FieldExprKind::Pow(20), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", Stage7FieldExprKind::Pow(21), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", Stage7FieldExprKind::Pow(22), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_7"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", Stage7FieldExprKind::Pow(23), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", Stage7FieldExprKind::Pow(24), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", Stage7FieldExprKind::Pow(25), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_8"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", Stage7FieldExprKind::Pow(26), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", Stage7FieldExprKind::Pow(27), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", Stage7FieldExprKind::Pow(28), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_9"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", Stage7FieldExprKind::Pow(29), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", Stage7FieldExprKind::Pow(30), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", Stage7FieldExprKind::Pow(31), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_10"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", Stage7FieldExprKind::Pow(32), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", Stage7FieldExprKind::Pow(33), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", Stage7FieldExprKind::Pow(34), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_11"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", Stage7FieldExprKind::Pow(35), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", Stage7FieldExprKind::Pow(36), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", Stage7FieldExprKind::Pow(37), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_12"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", Stage7FieldExprKind::Pow(38), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", Stage7FieldExprKind::Pow(39), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", Stage7FieldExprKind::Pow(40), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_13"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", Stage7FieldExprKind::Pow(41), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", Stage7FieldExprKind::Pow(42), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", Stage7FieldExprKind::Pow(43), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_14"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", Stage7FieldExprKind::Pow(44), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", Stage7FieldExprKind::Pow(45), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", Stage7FieldExprKind::Pow(46), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_15"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", Stage7FieldExprKind::Pow(47), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", Stage7FieldExprKind::Pow(48), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", Stage7FieldExprKind::Pow(49), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_16"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", Stage7FieldExprKind::Pow(50), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", Stage7FieldExprKind::Pow(51), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", Stage7FieldExprKind::Pow(52), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_17"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", Stage7FieldExprKind::Pow(53), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", Stage7FieldExprKind::Pow(54), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", Stage7FieldExprKind::Pow(55), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_18"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", Stage7FieldExprKind::Pow(56), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", Stage7FieldExprKind::Pow(57), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", Stage7FieldExprKind::Pow(58), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_19"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", Stage7FieldExprKind::Pow(59), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", Stage7FieldExprKind::Pow(60), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", Stage7FieldExprKind::Pow(61), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_20"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", Stage7FieldExprKind::Pow(62), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", Stage7FieldExprKind::Pow(63), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", Stage7FieldExprKind::Pow(64), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_21"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", Stage7FieldExprKind::Pow(65), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", Stage7FieldExprKind::Pow(66), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", Stage7FieldExprKind::Pow(67), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_22"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", Stage7FieldExprKind::Pow(68), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", Stage7FieldExprKind::Pow(69), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", Stage7FieldExprKind::Pow(70), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_23"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", Stage7FieldExprKind::Pow(71), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", Stage7FieldExprKind::Pow(72), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", Stage7FieldExprKind::Pow(73), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_24"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", Stage7FieldExprKind::Pow(74), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", Stage7FieldExprKind::Pow(75), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", Stage7FieldExprKind::Pow(76), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_25"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", Stage7FieldExprKind::Pow(77), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", Stage7FieldExprKind::Pow(78), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", Stage7FieldExprKind::Pow(79), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_26"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", Stage7FieldExprKind::Pow(80), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", Stage7FieldExprKind::Pow(81), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", Stage7FieldExprKind::Pow(82), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_27"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", Stage7FieldExprKind::Pow(83), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", Stage7FieldExprKind::Pow(84), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", Stage7FieldExprKind::Pow(85), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_28"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", Stage7FieldExprKind::Pow(86), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", Stage7FieldExprKind::Pow(87), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", Stage7FieldExprKind::Pow(88), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_29"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", Stage7FieldExprKind::Pow(89), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", Stage7FieldExprKind::Pow(90), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", Stage7FieldExprKind::Pow(91), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_30"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", Stage7FieldExprKind::Pow(92), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", Stage7FieldExprKind::Pow(93), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", Stage7FieldExprKind::Pow(94), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow|stage7.input.stage6.booleanity.InstructionRa_31"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", Stage7FieldExprKind::Pow(95), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow|stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", Stage7FieldExprKind::Pow(96), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow|stage7.field.one"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", Stage7FieldExprKind::Pow(97), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", Stage7FieldExprKind::Pow(98), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", Stage7FieldExprKind::Pow(99), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", Stage7FieldExprKind::Pow(100), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_1"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", Stage7FieldExprKind::Pow(101), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", Stage7FieldExprKind::Pow(102), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow|stage7.field.one"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", Stage7FieldExprKind::Pow(103), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow|stage7.input.stage6.booleanity.BytecodeRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", Stage7FieldExprKind::Pow(104), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow|stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", Stage7FieldExprKind::Pow(105), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", Stage7FieldExprKind::Pow(106), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", Stage7FieldExprKind::Pow(107), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_0"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", Stage7FieldExprKind::Pow(108), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", Stage7FieldExprKind::Pow(109), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", Stage7FieldExprKind::Pow(110), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_1"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", Stage7FieldExprKind::Pow(111), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", Stage7FieldExprKind::Pow(112), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_2"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", Stage7FieldExprKind::Pow(113), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_2"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", Stage7FieldExprKind::Pow(114), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow|stage7.input.stage6.hamming_booleanity.HammingWeight"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", Stage7FieldExprKind::Pow(115), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow|stage7.input.stage6.booleanity.RamRa_3"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", Stage7FieldExprKind::Pow(116), "stage7.hamming_weight_claim_reduction.gamma"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term", Stage7FieldExprKind::Mul, "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow|stage7.input.stage6.ram_ra_virtual.RamRa_3"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial0", Stage7FieldExprKind::Add, "stage7.field.one|stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial1", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial0|stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial2", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial1|stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial3", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial2|stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial4", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial3|stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial5", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial4|stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial6", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial5|stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial7", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial6|stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial8", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial7|stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial9", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial8|stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial10", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial9|stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial11", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial10|stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial12", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial11|stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial13", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial12|stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial14", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial13|stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial15", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial14|stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial16", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial15|stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial17", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial16|stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial18", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial17|stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial19", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial18|stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial20", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial19|stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial21", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial20|stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial22", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial21|stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial23", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial22|stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial24", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial23|stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial25", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial24|stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial26", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial25|stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial27", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial26|stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial28", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial27|stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial29", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial28|stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial30", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial29|stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial31", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial30|stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial32", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial31|stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial33", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial32|stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial34", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial33|stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial35", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial34|stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial36", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial35|stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial37", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial36|stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial38", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial37|stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial39", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial38|stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial40", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial39|stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial41", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial40|stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial42", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial41|stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial43", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial42|stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial44", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial43|stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial45", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial44|stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial46", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial45|stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial47", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial46|stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial48", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial47|stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial49", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial48|stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial50", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial49|stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial51", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial50|stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial52", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial51|stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial53", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial52|stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial54", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial53|stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial55", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial54|stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial56", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial55|stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial57", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial56|stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial58", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial57|stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial59", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial58|stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial60", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial59|stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial61", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial60|stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial62", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial61|stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial63", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial62|stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial64", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial63|stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial65", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial64|stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial66", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial65|stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial67", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial66|stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial68", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial67|stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial69", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial68|stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial70", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial69|stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial71", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial70|stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial72", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial71|stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial73", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial72|stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial74", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial73|stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial75", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial74|stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial76", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial75|stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial77", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial76|stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial78", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial77|stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial79", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial78|stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial80", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial79|stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial81", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial80|stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial82", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial81|stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial83", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial82|stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial84", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial83|stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial85", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial84|stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial86", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial85|stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial87", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial86|stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial88", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial87|stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial89", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial88|stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial90", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial89|stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial91", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial90|stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial92", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial91|stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial93", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial92|stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial94", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial93|stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial95", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial94|stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial96", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial95|stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial97", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial96|stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial98", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial97|stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial99", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial98|stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial100", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial99|stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial101", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial100|stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial102", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial101|stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial103", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial102|stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial104", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial103|stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial105", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial104|stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial106", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial105|stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial107", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial106|stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial108", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial107|stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial109", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial108|stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial110", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial109|stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial111", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial110|stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial111|stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial112|stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial113|stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, "stage7.hamming_weight_claim_reduction.claim_expr.partial114|stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", Stage7FieldExprKind::Pow(1), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", Stage7FieldExprKind::Pow(2), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", Stage7FieldExprKind::Pow(3), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", Stage7FieldExprKind::Pow(4), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_1"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", Stage7FieldExprKind::Pow(5), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", Stage7FieldExprKind::Pow(6), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", Stage7FieldExprKind::Pow(7), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_2"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", Stage7FieldExprKind::Pow(8), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", Stage7FieldExprKind::Pow(9), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", Stage7FieldExprKind::Pow(10), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_3"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", Stage7FieldExprKind::Pow(11), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", Stage7FieldExprKind::Pow(12), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", Stage7FieldExprKind::Pow(13), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_4"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", Stage7FieldExprKind::Pow(14), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", Stage7FieldExprKind::Pow(15), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", Stage7FieldExprKind::Pow(16), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_5"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", Stage7FieldExprKind::Pow(17), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", Stage7FieldExprKind::Pow(18), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", Stage7FieldExprKind::Pow(19), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_6"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", Stage7FieldExprKind::Pow(20), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", Stage7FieldExprKind::Pow(21), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", Stage7FieldExprKind::Pow(22), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_7"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", Stage7FieldExprKind::Pow(23), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", Stage7FieldExprKind::Pow(24), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", Stage7FieldExprKind::Pow(25), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_8"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", Stage7FieldExprKind::Pow(26), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", Stage7FieldExprKind::Pow(27), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", Stage7FieldExprKind::Pow(28), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_9"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", Stage7FieldExprKind::Pow(29), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", Stage7FieldExprKind::Pow(30), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", Stage7FieldExprKind::Pow(31), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_10"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", Stage7FieldExprKind::Pow(32), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", Stage7FieldExprKind::Pow(33), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", Stage7FieldExprKind::Pow(34), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_11"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", Stage7FieldExprKind::Pow(35), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", Stage7FieldExprKind::Pow(36), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", Stage7FieldExprKind::Pow(37), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_12"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", Stage7FieldExprKind::Pow(38), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", Stage7FieldExprKind::Pow(39), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", Stage7FieldExprKind::Pow(40), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_13"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", Stage7FieldExprKind::Pow(41), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", Stage7FieldExprKind::Pow(42), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", Stage7FieldExprKind::Pow(43), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_14"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", Stage7FieldExprKind::Pow(44), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", Stage7FieldExprKind::Pow(45), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", Stage7FieldExprKind::Pow(46), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_15"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", Stage7FieldExprKind::Pow(47), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", Stage7FieldExprKind::Pow(48), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", Stage7FieldExprKind::Pow(49), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_16"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", Stage7FieldExprKind::Pow(50), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", Stage7FieldExprKind::Pow(51), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", Stage7FieldExprKind::Pow(52), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_17"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", Stage7FieldExprKind::Pow(53), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", Stage7FieldExprKind::Pow(54), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", Stage7FieldExprKind::Pow(55), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_18"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", Stage7FieldExprKind::Pow(56), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", Stage7FieldExprKind::Pow(57), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", Stage7FieldExprKind::Pow(58), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_19"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", Stage7FieldExprKind::Pow(59), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", Stage7FieldExprKind::Pow(60), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", Stage7FieldExprKind::Pow(61), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_20"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", Stage7FieldExprKind::Pow(62), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", Stage7FieldExprKind::Pow(63), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", Stage7FieldExprKind::Pow(64), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_21"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", Stage7FieldExprKind::Pow(65), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", Stage7FieldExprKind::Pow(66), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", Stage7FieldExprKind::Pow(67), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_22"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", Stage7FieldExprKind::Pow(68), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", Stage7FieldExprKind::Pow(69), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", Stage7FieldExprKind::Pow(70), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_23"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", Stage7FieldExprKind::Pow(71), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", Stage7FieldExprKind::Pow(72), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", Stage7FieldExprKind::Pow(73), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_24"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", Stage7FieldExprKind::Pow(74), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", Stage7FieldExprKind::Pow(75), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", Stage7FieldExprKind::Pow(76), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_25"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", Stage7FieldExprKind::Pow(77), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", Stage7FieldExprKind::Pow(78), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", Stage7FieldExprKind::Pow(79), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_26"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", Stage7FieldExprKind::Pow(80), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", Stage7FieldExprKind::Pow(81), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", Stage7FieldExprKind::Pow(82), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_27"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", Stage7FieldExprKind::Pow(83), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", Stage7FieldExprKind::Pow(84), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", Stage7FieldExprKind::Pow(85), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_28"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", Stage7FieldExprKind::Pow(86), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", Stage7FieldExprKind::Pow(87), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", Stage7FieldExprKind::Pow(88), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_29"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", Stage7FieldExprKind::Pow(89), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", Stage7FieldExprKind::Pow(90), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", Stage7FieldExprKind::Pow(91), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_30"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", Stage7FieldExprKind::Pow(92), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", Stage7FieldExprKind::Pow(93), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", Stage7FieldExprKind::Pow(94), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_31"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", Stage7FieldExprKind::Pow(95), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", Stage7FieldExprKind::Pow(96), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", Stage7FieldExprKind::Pow(97), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", Stage7FieldExprKind::Pow(98), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", Stage7FieldExprKind::Pow(99), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", Stage7FieldExprKind::Pow(100), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_1"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", Stage7FieldExprKind::Pow(101), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", Stage7FieldExprKind::Pow(102), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", Stage7FieldExprKind::Pow(103), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_2"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", Stage7FieldExprKind::Pow(104), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", Stage7FieldExprKind::Pow(105), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", Stage7FieldExprKind::Pow(106), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", Stage7FieldExprKind::Pow(107), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", Stage7FieldExprKind::Pow(108), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", Stage7FieldExprKind::Pow(109), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_1"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", Stage7FieldExprKind::Pow(110), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_1"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", Stage7FieldExprKind::Pow(111), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", Stage7FieldExprKind::Pow(112), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_2"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", Stage7FieldExprKind::Pow(113), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_2"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", Stage7FieldExprKind::Pow(114), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", Stage7FieldExprKind::Pow(115), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_3"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", Stage7FieldExprKind::Pow(116), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial0", Stage7FieldExprKind::Add, &["stage7.field.one", "stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial1", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial0", "stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial2", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial1", "stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial3", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial2", "stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial4", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial3", "stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial5", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial4", "stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial6", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial5", "stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial7", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial6", "stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial8", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial7", "stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial9", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial8", "stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial10", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial9", "stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial11", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial10", "stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial12", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial11", "stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial13", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial12", "stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial14", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial13", "stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial15", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial14", "stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial16", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial15", "stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial17", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial16", "stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial18", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial17", "stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial19", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial18", "stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial20", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial19", "stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial21", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial20", "stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial22", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial21", "stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial23", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial22", "stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial24", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial23", "stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial25", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial24", "stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial26", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial25", "stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial27", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial26", "stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial28", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial27", "stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial29", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial28", "stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial30", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial29", "stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial31", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial30", "stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial32", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial31", "stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial33", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial32", "stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial34", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial33", "stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial35", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial34", "stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial36", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial35", "stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial37", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial36", "stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial38", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial37", "stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial39", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial38", "stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial40", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial39", "stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial41", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial40", "stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial42", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial41", "stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial43", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial42", "stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial44", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial43", "stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial45", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial44", "stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial46", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial45", "stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial47", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial46", "stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial48", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial47", "stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial49", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial48", "stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial50", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial49", "stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial51", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial50", "stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial52", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial51", "stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial53", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial52", "stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial54", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial53", "stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial55", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial54", "stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial56", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial55", "stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial57", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial56", "stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial58", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial57", "stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial59", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial58", "stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial60", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial59", "stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial61", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial60", "stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial62", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial61", "stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial63", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial62", "stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial64", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial63", "stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial65", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial64", "stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial66", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial65", "stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial67", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial66", "stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial68", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial67", "stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial69", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial68", "stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial70", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial69", "stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial71", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial70", "stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial72", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial71", "stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial73", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial72", "stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial74", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial73", "stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial75", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial74", "stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial76", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial75", "stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial77", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial76", "stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial78", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial77", "stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial79", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial78", "stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial80", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial79", "stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial81", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial80", "stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial82", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial81", "stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial83", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial82", "stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial84", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial83", "stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial85", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial84", "stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial86", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial85", "stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial87", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial86", "stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial88", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial87", "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial89", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial88", "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial90", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial89", "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial91", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial90", "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial92", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial91", "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial93", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial92", "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial94", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial93", "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial95", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial94", "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial96", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial95", "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial97", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial96", "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial98", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial97", "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial99", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial98", "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial100", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial99", "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial101", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial100", "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial102", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial101", "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial103", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial102", "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial104", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial103", "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial105", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial104", "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial106", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial105", "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial107", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial106", "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial108", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial107", "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial109", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial108", "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial110", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial109", "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial111", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial110", "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"]), + stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"]), ]; pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ From 974b1779cf8c015cdf6539458803ebea814e6e50 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 18:37:04 -0600 Subject: [PATCH 005/171] fix(equivalence): adapt oracle to typed verifier plans --- crates/jolt-equivalence/src/plan_adapters.rs | 424 +++++++++++++++--- crates/jolt-equivalence/src/tamper.rs | 2 +- .../tests/generated_role_crates.rs | 4 +- crates/jolt-verifier/src/stages/common.rs | 2 +- 4 files changed, 363 insertions(+), 69 deletions(-) diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index b577452cbf..1cecfcbf3b 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -26,15 +26,14 @@ macro_rules! stage_field_expr { (generated, $module:ident, $field_expr:ident, $plan:ident) => { $module::$field_expr { symbol: super::leak_str(&$plan.symbol), - kind: super::leak_str(&$plan.kind), - formula: super::leak_str(&$plan.formula), - operands: super::leak_symbol_list(&$plan.operands), + kind: generated_field_expr_kind!($plan.formula.as_str()), + operands: super::leak_str_slice(&$plan.operands), } }; } macro_rules! stage_claim { - ($mode:ident, $module:ident, $claim:ident, $plan:ident) => { + (kernel, $module:ident, $claim:ident, $plan:ident) => { $module::$claim { symbol: super::leak_str(&$plan.symbol), stage: super::leak_str(&$plan.stage), @@ -45,13 +44,30 @@ macro_rules! stage_claim { kernel: $plan.kernel.as_deref().map(super::leak_str), relation: $plan.relation.as_deref().map(super::leak_str), claim_value: super::leak_str(&$plan.claim_value), - input_openings: stage_list!($mode, &$plan.input_openings), + input_openings: stage_list!(kernel, &$plan.input_openings), + } + }; + (generated, $module:ident, $claim:ident, $plan:ident) => { + $module::$claim { + symbol: super::leak_str(&$plan.symbol), + stage: super::leak_str(&$plan.stage), + domain: super::leak_str(&$plan.domain), + num_rounds: $plan.num_rounds, + degree: $plan.degree, + claim: super::leak_str(&$plan.claim), + kernel: $plan.kernel.as_deref().map(super::leak_str), + relation: $plan + .relation + .as_deref() + .map(|relation| generated_relation_kind!(relation)), + claim_value: super::leak_str(&$plan.claim_value), + input_openings: stage_list!(generated, &$plan.input_openings), } }; } macro_rules! stage_driver { - ($module:ident, $driver:ident, $plan:ident) => { + (kernel, $module:ident, $driver:ident, $plan:ident) => { $module::$driver { symbol: super::leak_str(&$plan.symbol), stage: super::leak_str(&$plan.stage), @@ -67,6 +83,240 @@ macro_rules! stage_driver { degree: $plan.degree, } }; + (generated, $module:ident, $driver:ident, $plan:ident) => { + $module::$driver { + symbol: super::leak_str(&$plan.symbol), + stage: super::leak_str(&$plan.stage), + proof_slot: super::leak_str(&$plan.proof_slot), + kernel: $plan.kernel.as_deref().map(super::leak_str), + relation: $plan + .relation + .as_deref() + .map(|relation| generated_relation_kind!(relation)), + batch: super::leak_str(&$plan.batch), + policy: super::leak_str(&$plan.policy), + round_schedule: super::leak_usize_slice(&$plan.round_schedule), + claim_label: super::leak_str(&$plan.claim_label), + round_label: super::leak_str(&$plan.round_label), + num_rounds: $plan.num_rounds, + degree: $plan.degree, + } + }; +} + +macro_rules! generated_program_step_kind { + ($value:expr) => { + match $value { + "transcript_squeeze" => { + jolt_verifier::stages::common::ProgramStepKind::TranscriptSqueeze + } + "transcript_absorb_bytes" => { + jolt_verifier::stages::common::ProgramStepKind::TranscriptAbsorbBytes + } + "sumcheck_driver" => jolt_verifier::stages::common::ProgramStepKind::SumcheckDriver, + value => panic!("unsupported generated program step kind `{value}`"), + } + }; +} + +macro_rules! generated_transcript_squeeze_kind { + ($value:expr) => { + match $value { + "challenge_scalar" => { + jolt_verifier::stages::common::TranscriptSqueezeKind::ChallengeScalar + } + "challenge_vector" => { + jolt_verifier::stages::common::TranscriptSqueezeKind::ChallengeVector + } + "scalar" => jolt_verifier::stages::common::TranscriptSqueezeKind::Scalar, + value => panic!("unsupported generated transcript squeeze kind `{value}`"), + } + }; +} + +macro_rules! generated_claim_kind { + ($value:expr) => { + match $value { + "committed" => jolt_verifier::stages::common::ClaimKind::Committed, + "virtual" => jolt_verifier::stages::common::ClaimKind::Virtual, + value => panic!("unsupported generated claim kind `{value}`"), + } + }; +} + +macro_rules! generated_relation_kind { + ($value:expr) => { + match $value { + "jolt.stage1.outer.uniskip" => { + jolt_verifier::stages::common::RelationKind::Stage1OuterUniskip + } + "jolt.stage1.outer.remaining" => { + jolt_verifier::stages::common::RelationKind::Stage1OuterRemaining + } + "jolt.stage2.product_virtual.uniskip" => { + jolt_verifier::stages::common::RelationKind::Stage2ProductVirtualUniskip + } + "jolt.stage2.ram.read_write" => { + jolt_verifier::stages::common::RelationKind::Stage2RamReadWrite + } + "jolt.stage2.product_virtual.remainder" => { + jolt_verifier::stages::common::RelationKind::Stage2ProductVirtualRemainder + } + "jolt.stage2.instruction_lookup.claim_reduction" => { + jolt_verifier::stages::common::RelationKind::Stage2InstructionLookupClaimReduction + } + "jolt.stage2.ram.raf_evaluation" => { + jolt_verifier::stages::common::RelationKind::Stage2RamRafEvaluation + } + "jolt.stage2.ram.output_check" => { + jolt_verifier::stages::common::RelationKind::Stage2RamOutputCheck + } + "jolt.stage2.batched" => jolt_verifier::stages::common::RelationKind::Stage2Batched, + "jolt.stage3.spartan_shift" => { + jolt_verifier::stages::common::RelationKind::Stage3SpartanShift + } + "jolt.stage3.instruction_input" => { + jolt_verifier::stages::common::RelationKind::Stage3InstructionInput + } + "jolt.stage3.registers_claim_reduction" => { + jolt_verifier::stages::common::RelationKind::Stage3RegistersClaimReduction + } + "jolt.stage3.batched" => jolt_verifier::stages::common::RelationKind::Stage3Batched, + "jolt.stage4.registers_read_write" => { + jolt_verifier::stages::common::RelationKind::Stage4RegistersReadWrite + } + "jolt.stage4.ram_val_check" => { + jolt_verifier::stages::common::RelationKind::Stage4RamValCheck + } + "jolt.stage4.batched" => jolt_verifier::stages::common::RelationKind::Stage4Batched, + "jolt.stage5.instruction_read_raf" => { + jolt_verifier::stages::common::RelationKind::Stage5InstructionReadRaf + } + "jolt.stage5.ram_ra_claim_reduction" => { + jolt_verifier::stages::common::RelationKind::Stage5RamRaClaimReduction + } + "jolt.stage5.registers_val_evaluation" => { + jolt_verifier::stages::common::RelationKind::Stage5RegistersValEvaluation + } + "jolt.stage5.batched" => jolt_verifier::stages::common::RelationKind::Stage5Batched, + "jolt.stage6.bytecode_read_raf" => { + jolt_verifier::stages::common::RelationKind::Stage6BytecodeReadRaf + } + "jolt.stage6.booleanity" => { + jolt_verifier::stages::common::RelationKind::Stage6Booleanity + } + "jolt.stage6.hamming_booleanity" => { + jolt_verifier::stages::common::RelationKind::Stage6HammingBooleanity + } + "jolt.stage6.ram_ra_virtual" => { + jolt_verifier::stages::common::RelationKind::Stage6RamRaVirtual + } + "jolt.stage6.instruction_ra_virtual" => { + jolt_verifier::stages::common::RelationKind::Stage6InstructionRaVirtual + } + "jolt.stage6.inc_claim_reduction" => { + jolt_verifier::stages::common::RelationKind::Stage6IncClaimReduction + } + "jolt.stage6.batched" => jolt_verifier::stages::common::RelationKind::Stage6Batched, + "jolt.stage7.hamming_weight_claim_reduction" => { + jolt_verifier::stages::common::RelationKind::Stage7HammingWeightClaimReduction + } + "jolt.stage7.batched" => jolt_verifier::stages::common::RelationKind::Stage7Batched, + value => panic!("unsupported generated relation `{value}`"), + } + }; +} + +macro_rules! generated_field_expr_kind { + ($value:expr) => {{ + let value = $value; + match value { + "opening_eval" => jolt_verifier::stages::common::FieldExprKind::OpeningEval, + "field.add" => jolt_verifier::stages::common::FieldExprKind::Add, + "field.sub" => jolt_verifier::stages::common::FieldExprKind::Sub, + "field.mul" => jolt_verifier::stages::common::FieldExprKind::Mul, + "field.neg" => jolt_verifier::stages::common::FieldExprKind::Neg, + value if value.starts_with("field.pow:") => { + let exponent = value + .strip_prefix("field.pow:") + .expect("field pow expression has prefix") + .parse::() + .expect("field pow expression has usize exponent"); + jolt_verifier::stages::common::FieldExprKind::Pow(exponent) + } + value if value.starts_with("poly.lagrange_basis_eval:") => { + let spec = value + .strip_prefix("poly.lagrange_basis_eval:") + .expect("lagrange expression has prefix"); + let parts = spec.split(':').collect::>(); + assert!(parts.len() == 3, "lagrange expression has three fields"); + jolt_verifier::stages::common::FieldExprKind::LagrangeBasisEval( + parts[0] + .parse::() + .expect("lagrange domain start is i64"), + parts[1] + .parse::() + .expect("lagrange domain size is usize"), + parts[2].parse::().expect("lagrange index is usize"), + ) + } + value => panic!("unsupported generated field expression kind `{value}`"), + } + }}; +} + +macro_rules! generated_opening_equality_mode { + ($value:expr) => { + match $value { + "point_and_eval" => jolt_verifier::stages::common::OpeningEqualityMode::PointAndEval, + value => panic!("unsupported generated opening equality mode `{value}`"), + } + }; +} + +macro_rules! stage_program_step_kind { + (kernel, $module:ident, $value:expr) => { + super::leak_str($value) + }; + (generated, $module:ident, $value:expr) => { + generated_program_step_kind!($value) + }; +} + +macro_rules! stage_transcript_squeeze_kind { + (kernel, $module:ident, $value:expr) => { + super::leak_str($value) + }; + (generated, $module:ident, $value:expr) => { + generated_transcript_squeeze_kind!($value) + }; +} + +macro_rules! stage_claim_kind { + (kernel, $module:ident, $value:expr) => { + super::leak_str($value) + }; + (generated, $module:ident, $value:expr) => { + generated_claim_kind!($value) + }; +} + +macro_rules! stage_relation_kind { + (kernel, $module:ident, $value:expr) => { + super::leak_str($value) + }; + (generated, $module:ident, $value:expr) => { + generated_relation_kind!($value) + }; +} + +macro_rules! stage_opening_equality_mode { + (kernel, $module:ident, $value:expr) => { + super::leak_str($value) + }; + (generated, $module:ident, $value:expr) => { + generated_opening_equality_mode!($value) + }; } macro_rules! define_stage_adapter_impl { @@ -112,7 +362,7 @@ macro_rules! define_stage_adapter_impl { .steps .iter() .map(|plan| $module::$step { - kind: super::leak_str(&plan.kind), + kind: stage_program_step_kind!($mode, $module, plan.kind.as_str()), symbol: super::leak_str(&plan.symbol), }) .collect(), @@ -124,7 +374,7 @@ macro_rules! define_stage_adapter_impl { .map(|plan| $module::$squeeze { symbol: super::leak_str(&plan.symbol), label: super::leak_str(&plan.label), - kind: super::leak_str(&plan.kind), + kind: stage_transcript_squeeze_kind!($mode, $module, plan.kind.as_str()), count: plan.count, }) .collect(), @@ -153,7 +403,7 @@ macro_rules! define_stage_adapter_impl { oracle: super::leak_str(&plan.oracle), domain: super::leak_str(&plan.domain), point_arity: plan.point_arity, - claim_kind: super::leak_str(&plan.claim_kind), + claim_kind: stage_claim_kind!($mode, $module, plan.claim_kind.as_str()), }) .collect(), ), @@ -219,7 +469,7 @@ macro_rules! define_stage_adapter_impl { program .drivers .iter() - .map(|plan| stage_driver!($module, $driver, plan)) + .map(|plan| stage_driver!($mode, $module, $driver, plan)) .collect(), ), instance_results: super::leak_slice( @@ -230,7 +480,7 @@ macro_rules! define_stage_adapter_impl { symbol: super::leak_str(&plan.symbol), source: super::leak_str(&plan.source), claim: super::leak_str(&plan.claim), - relation: super::leak_str(&plan.relation), + relation: stage_relation_kind!($mode, $module, plan.relation.as_str()), index: plan.index, point_arity: plan.point_arity, num_rounds: plan.num_rounds, @@ -300,7 +550,7 @@ macro_rules! define_stage_adapter_impl { oracle: super::leak_str(&plan.oracle), domain: super::leak_str(&plan.domain), point_arity: plan.point_arity, - claim_kind: super::leak_str(&plan.claim_kind), + claim_kind: stage_claim_kind!($mode, $module, plan.claim_kind.as_str()), point_source: super::leak_str(&plan.point_source), eval_source: super::leak_str(&plan.eval_source), }) @@ -313,7 +563,7 @@ macro_rules! define_stage_adapter_impl { .iter() .map(|plan| $module::$opening_equality { symbol: super::leak_str(&plan.symbol), - mode: super::leak_str(&plan.mode), + mode: stage_opening_equality_mode!($mode, $module, plan.mode.as_str()), lhs: super::leak_str(&plan.lhs), rhs: super::leak_str(&plan.rhs), }) @@ -481,7 +731,7 @@ macro_rules! define_stage1_adapter { .map(|plan| $module::$squeeze { symbol: super::leak_str(&plan.symbol), label: super::leak_str(&plan.label), - kind: super::leak_str(&plan.kind), + kind: stage_transcript_squeeze_kind!($mode, $module, plan.kind.as_str()), count: plan.count, }) .collect(), @@ -530,7 +780,7 @@ macro_rules! define_stage1_adapter { program .drivers .iter() - .map(|plan| stage_driver!($module, $driver, plan)) + .map(|plan| stage_driver!($mode, $module, $driver, plan)) .collect(), ), instance_results: super::leak_slice( @@ -541,7 +791,7 @@ macro_rules! define_stage1_adapter { symbol: super::leak_str(&plan.symbol), source: super::leak_str(&plan.source), claim: super::leak_str(&plan.claim), - relation: super::leak_str(&plan.relation), + relation: stage_relation_kind!($mode, $module, plan.relation.as_str()), index: plan.index, point_arity: plan.point_arity, num_rounds: plan.num_rounds, @@ -573,7 +823,7 @@ macro_rules! define_stage1_adapter { oracle: super::leak_str(&plan.oracle), domain: super::leak_str(&plan.domain), point_arity: plan.point_arity, - claim_kind: super::leak_str(&plan.claim_kind), + claim_kind: stage_claim_kind!($mode, $module, plan.claim_kind.as_str()), point_source: super::leak_str(&plan.point_source), eval_source: super::leak_str(&plan.eval_source), }) @@ -638,16 +888,94 @@ use bolt::Role; use jolt_prover::stages::stage8 as generated_prover_stage8; use jolt_verifier::stages::stage8 as generated_stage8; +macro_rules! stage8_source_stage { + ($module:ident, $value:expr) => { + match $value { + "stage6" => $module::Stage8SourceStage::Stage6, + "stage7" => $module::Stage8SourceStage::Stage7, + value => panic!("unsupported Stage 8 source stage `{value}`"), + } + }; +} + +macro_rules! stage8_claim_kind { + ($module:ident, $value:expr) => { + match $value { + "committed" => $module::Stage8ClaimKind::Committed, + "virtual" => $module::Stage8ClaimKind::Virtual, + value => panic!("unsupported Stage 8 claim kind `{value}`"), + } + }; +} + +macro_rules! stage8_pcs_proof_mode { + ($module:ident, $value:expr) => { + match $value { + "open" => $module::Stage8PcsProofMode::Open, + "verify" => $module::Stage8PcsProofMode::Verify, + value => panic!("unsupported Stage 8 PCS proof mode `{value}`"), + } + }; +} + macro_rules! define_stage8_adapter { ($function:ident, $module:ident) => { pub(crate) fn $function( program: &CompilerStage8CpuProgram, ) -> &'static $module::Stage8EvaluationProgramPlan { - let evaluation_point_source = program - .opening_inputs + let opening_inputs = leak_slice( + program + .opening_inputs + .iter() + .map(|plan| $module::Stage8OpeningInputPlan { + symbol: $module::Stage8OpeningInputSymbol::new(leak_str(&plan.symbol)), + source_stage: stage8_source_stage!($module, plan.source_stage.as_str()), + source_claim: $module::Stage8SourceClaim::new(leak_str(&plan.source_claim)), + oracle: leak_str(&plan.oracle), + domain: leak_str(&plan.domain), + point_arity: plan.point_arity, + claim_kind: stage8_claim_kind!($module, plan.claim_kind.as_str()), + }) + .collect(), + ); + let opening_claims = leak_slice( + program + .opening_claims + .iter() + .map(|plan| $module::Stage8OpeningClaimPlan { + symbol: $module::Stage8OpeningClaimSymbol::new(leak_str(&plan.symbol)), + oracle: leak_str(&plan.oracle), + family: leak_str(&plan.family), + domain: leak_str(&plan.domain), + point_arity: plan.point_arity, + point_source: $module::Stage8OpeningInputSymbol::new(leak_str( + &plan.point_source, + )), + eval_source: $module::Stage8OpeningInputSymbol::new(leak_str( + &plan.eval_source, + )), + source_stage: stage8_source_stage!($module, plan.source_stage.as_str()), + source_claim: $module::Stage8SourceClaim::new(leak_str(&plan.source_claim)), + }) + .collect(), + ); + let evaluation_point_source = opening_inputs .iter() - .find(|input| input.symbol == "stage8.evaluation.point_source") + .find(|input| input.symbol.as_str() == "stage8.evaluation.point_source") + .copied() .expect("stage8 evaluation point source exists"); + let ordered_claims = leak_slice( + program.opening_batches[0] + .ordered_claims + .iter() + .map(|symbol| { + *opening_claims + .iter() + .find(|claim| claim.symbol.as_str() == symbol) + .expect("stage8 opening batch claim exists") + }) + .collect(), + ); Box::leak(Box::new($module::Stage8EvaluationProgramPlan { role: role_name(&program.role), function: leak_str(&program.function), @@ -656,61 +984,27 @@ macro_rules! define_stage8_adapter { pcs: leak_str(&program.params.pcs), transcript: leak_str(&program.params.transcript), }, - evaluation_point_source: $module::Stage8OpeningInputPlan { - symbol: leak_str(&evaluation_point_source.symbol), - source_stage: leak_str(&evaluation_point_source.source_stage), - source_claim: leak_str(&evaluation_point_source.source_claim), - oracle: leak_str(&evaluation_point_source.oracle), - domain: leak_str(&evaluation_point_source.domain), - point_arity: evaluation_point_source.point_arity, - claim_kind: leak_str(&evaluation_point_source.claim_kind), - }, - opening_inputs: leak_slice( - program - .opening_inputs - .iter() - .map(|plan| $module::Stage8OpeningInputPlan { - symbol: leak_str(&plan.symbol), - source_stage: leak_str(&plan.source_stage), - source_claim: leak_str(&plan.source_claim), - oracle: leak_str(&plan.oracle), - domain: leak_str(&plan.domain), - point_arity: plan.point_arity, - claim_kind: leak_str(&plan.claim_kind), - }) - .collect(), - ), - opening_claims: leak_slice( - program - .opening_claims - .iter() - .map(|plan| $module::Stage8OpeningClaimPlan { - symbol: leak_str(&plan.symbol), - oracle: leak_str(&plan.oracle), - family: leak_str(&plan.family), - domain: leak_str(&plan.domain), - point_arity: plan.point_arity, - point_source: leak_str(&plan.point_source), - eval_source: leak_str(&plan.eval_source), - source_stage: leak_str(&plan.source_stage), - source_claim: leak_str(&plan.source_claim), - }) - .collect(), - ), + evaluation_point_source, + opening_inputs, + opening_claims, opening_batch: $module::Stage8OpeningBatchPlan { - symbol: leak_str(&program.opening_batches[0].symbol), + symbol: $module::Stage8OpeningBatchSymbol::new(leak_str( + &program.opening_batches[0].symbol, + )), proof_slot: leak_str(&program.opening_batches[0].proof_slot), policy: leak_str(&program.opening_batches[0].policy), count: program.opening_batches[0].count, - ordered_claims: leak_str_slice(&program.opening_batches[0].ordered_claims), + ordered_claims, }, pcs_proof: $module::Stage8PcsProofPlan { symbol: leak_str(&program.pcs_proofs[0].symbol), - mode: leak_str(&program.pcs_proofs[0].mode), + mode: stage8_pcs_proof_mode!($module, program.pcs_proofs[0].mode.as_str()), pcs: leak_str(&program.pcs_proofs[0].pcs), proof_slot: leak_str(&program.pcs_proofs[0].proof_slot), transcript_label: leak_str(&program.pcs_proofs[0].transcript_label), - batch: leak_str(&program.pcs_proofs[0].batch), + batch: $module::Stage8OpeningBatchSymbol::new(leak_str( + &program.pcs_proofs[0].batch, + )), }, })) } diff --git a/crates/jolt-equivalence/src/tamper.rs b/crates/jolt-equivalence/src/tamper.rs index aeceeb6db6..49c28f2d78 100644 --- a/crates/jolt-equivalence/src/tamper.rs +++ b/crates/jolt-equivalence/src/tamper.rs @@ -307,7 +307,7 @@ pub(crate) fn assert_monolithic_jolt_tamper_rejected(input: MonolithicJoltTamper .len(); let tampered_stage7_openings = tampered_opening_input_suffix_point( input.inputs.stage7_openings, - stage8_source_symbol, + stage8_source_symbol.as_str(), stage7_address_prefix_len, ); let mut tampered_stage7_opening_inputs = input.inputs; diff --git a/crates/jolt-equivalence/tests/generated_role_crates.rs b/crates/jolt-equivalence/tests/generated_role_crates.rs index 69237f6eab..30ec58cd85 100644 --- a/crates/jolt-equivalence/tests/generated_role_crates.rs +++ b/crates/jolt-equivalence/tests/generated_role_crates.rs @@ -77,11 +77,11 @@ fn generated_role_crates_expose_matching_stage_prefix() { .is_empty()); assert_eq!( jolt_prover::stages::stage8::STAGE8_PROGRAM.pcs_proof.mode, - "open" + jolt_prover::stages::stage8::Stage8PcsProofMode::Open ); assert_eq!( jolt_verifier::stages::stage8::STAGE8_PROGRAM.pcs_proof.mode, - "verify" + jolt_verifier::stages::stage8::Stage8PcsProofMode::Verify ); let _proof = jolt_verifier::JoltProof { commitments: Vec::new(), diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs index c67b3876da..94bd830e85 100644 --- a/crates/jolt-verifier/src/stages/common.rs +++ b/crates/jolt-verifier/src/stages/common.rs @@ -28,7 +28,7 @@ pub struct TypedPlanSymbol { } impl TypedPlanSymbol { - pub(crate) const fn new(symbol: &'static str) -> Self { + pub const fn new(symbol: &'static str) -> Self { Self { symbol, _tag: PhantomData, From a41570b25b2bf3837ef4e478b4ff0fef974a8a40 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 18:48:58 -0600 Subject: [PATCH 006/171] refactor(bolt): structure verifier batch operands --- .../src/protocols/jolt/emit/rust/stage1.rs | 8 +++---- .../src/protocols/jolt/emit/rust/stage2.rs | 13 ++++++----- .../src/protocols/jolt/emit/rust/stage3.rs | 8 +++---- .../src/protocols/jolt/emit/rust/stage4.rs | 8 +++---- .../src/protocols/jolt/emit/rust/stage5.rs | 8 +++---- .../src/protocols/jolt/emit/rust/stage6.rs | 8 +++---- .../src/protocols/jolt/emit/rust/stage7.rs | 8 +++---- .../jolt/verifier_common.rs.template | 17 ++++++++------ crates/bolt/tests/verifier_cleanup.rs | 18 +++++++++++++++ crates/jolt-equivalence/src/plan_adapters.rs | 22 ++++++++++++------- crates/jolt-verifier/src/stages/common.rs | 15 ++++++++----- .../jolt-verifier/src/stages/stage1_outer.rs | 6 ++--- crates/jolt-verifier/src/stages/stage2.rs | 11 ++++++---- crates/jolt-verifier/src/stages/stage3.rs | 4 ++-- crates/jolt-verifier/src/stages/stage4.rs | 4 ++-- crates/jolt-verifier/src/stages/stage5.rs | 4 ++-- crates/jolt-verifier/src/stages/stage6.rs | 4 ++-- crates/jolt-verifier/src/stages/stage7.rs | 4 ++-- 18 files changed, 103 insertions(+), 67 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs index 99b6f87b17..3a8d18bdaa 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs @@ -872,8 +872,8 @@ impl Stage1CpuProgram { rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")), + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) ) @@ -1024,8 +1024,8 @@ impl Stage1CpuProgram { rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 2a67a18fa7..91cd3a87bf 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -1343,8 +1343,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")), + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) ) @@ -1637,8 +1637,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands) ) }) .collect::>() @@ -2057,7 +2057,10 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, batch: &Stage2SumcheckBatchPlan, ) -> Result, VerifyStage2Error> { - super::common::symbol_list(batch.claim_operands) + batch + .claim_operands + .iter() + .copied() .map(|symbol| { let claim = find_plan(program.claims, symbol).ok_or(VerifyStage2Error::MissingClaim { batch: batch.symbol, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index c2243ccfef..21f23cfd10 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1347,8 +1347,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")), + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) ) @@ -1666,8 +1666,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index f5e2d896d3..782fa01da9 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -1567,8 +1567,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")), + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) ) @@ -1856,8 +1856,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 3d65786c34..44495d2da6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1569,8 +1569,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")), + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) ) @@ -1858,8 +1858,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index c2f5976d85..9e548d1149 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1709,8 +1709,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")), + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) ) @@ -2025,8 +2025,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 09d372b288..35d6d77be6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1605,8 +1605,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")), + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) ) @@ -1921,8 +1921,8 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str(&batch.ordered_claims.join("|")), - rust_str(&batch.claim_operands.join("|")) + super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), + super::plan_tokens::rust_str_slice_expr(&batch.claim_operands) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/verifier_common.rs.template b/crates/bolt/src/protocols/jolt/verifier_common.rs.template index c67b3876da..0018ad477e 100644 --- a/crates/bolt/src/protocols/jolt/verifier_common.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_common.rs.template @@ -28,7 +28,7 @@ pub struct TypedPlanSymbol { } impl TypedPlanSymbol { - pub(crate) const fn new(symbol: &'static str) -> Self { + pub const fn new(symbol: &'static str) -> Self { Self { symbol, _tag: PhantomData, @@ -187,8 +187,8 @@ pub struct SumcheckBatchPlan { pub proof_slot: &'static str, pub policy: &'static str, pub count: usize, - pub ordered_claims: &'static str, - pub claim_operands: &'static str, + pub ordered_claims: &'static [&'static str], + pub claim_operands: &'static [&'static str], pub claim_label: &'static str, pub round_label: &'static str, pub round_schedule: &'static [usize], @@ -288,8 +288,8 @@ pub struct OpeningBatchPlan { pub proof_slot: &'static str, pub policy: &'static str, pub count: usize, - pub ordered_claims: &'static str, - pub claim_operands: &'static str, + pub ordered_claims: &'static [&'static str], + pub claim_operands: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -867,7 +867,10 @@ pub fn batch_claims<'a, C: SymbolPlan>( claims: &'a [C], batch: &SumcheckBatchPlan, ) -> Result, RuntimePlanError> { - symbol_list(batch.claim_operands) + batch + .claim_operands + .iter() + .copied() .map(|symbol| { find_plan(claims, symbol).ok_or(RuntimePlanError::MissingClaim { batch: batch.symbol, @@ -1822,7 +1825,7 @@ where }) .collect::>(); for batch in opening_batches { - for symbol in symbol_list(batch.claim_operands) { + for &symbol in batch.claim_operands { let claim = opening_claims .iter() .find(|claim| claim.symbol == symbol) diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 22304ce85f..2a09b3a379 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -18,6 +18,7 @@ const VERIFIER_RS_BASELINE_LOC_CEILING: usize = VERIFIER_RS_TARGET_LOC; const STAGE6_STAGE7_BASELINE_LOC_CEILING: usize = STAGE6_STAGE7_TARGET_LOC; const STAGE_LOCAL_PLAN_STRUCT_BASELINE_CEILING: usize = 18; const FIELD_EXPR_OPERAND_CONSTANT_BASELINE_CEILING: usize = 0; +const BATCH_OPERAND_STRING_SITE_BASELINE_CEILING: usize = 0; const STAGE_HELPER_FUNCTION_BASELINE_CEILING: usize = 38; const RELATION_STRING_SITE_BASELINE_CEILING: usize = 0; @@ -114,6 +115,7 @@ struct VerifierCleanupMetrics { stage6_stage7_loc: usize, stage_local_generic_plan_structs: usize, field_expr_operand_constants: usize, + batch_operand_string_sites: usize, stage_local_helper_functions: usize, relation_string_sites: usize, } @@ -135,6 +137,7 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { stage6_stage7_loc: {stage6_stage7_loc} (target <= {stage67_target}, baseline ceiling <= {stage67_baseline})\n\ stage_local_generic_plan_structs: {plan_structs} (baseline ceiling <= {plan_baseline})\n\ field_expr_operand_constants: {operand_constants} (baseline ceiling <= {operand_baseline})\n\ + batch_operand_string_sites: {batch_operand_string_sites} (baseline ceiling <= {batch_operand_baseline})\n\ stage_local_helper_functions: {helper_functions} (baseline ceiling <= {helper_baseline})\n\ relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})", generated_surface_loc = metrics.generated_surface_loc, @@ -155,6 +158,8 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { plan_baseline = STAGE_LOCAL_PLAN_STRUCT_BASELINE_CEILING, operand_constants = metrics.field_expr_operand_constants, operand_baseline = FIELD_EXPR_OPERAND_CONSTANT_BASELINE_CEILING, + batch_operand_string_sites = metrics.batch_operand_string_sites, + batch_operand_baseline = BATCH_OPERAND_STRING_SITE_BASELINE_CEILING, helper_functions = metrics.stage_local_helper_functions, helper_baseline = STAGE_HELPER_FUNCTION_BASELINE_CEILING, relation_sites = metrics.relation_string_sites, @@ -200,6 +205,11 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { "field-expression operand constants grew to {}; compact field expression encoding", metrics.field_expr_operand_constants ); + assert!( + metrics.batch_operand_string_sites == BATCH_OPERAND_STRING_SITE_BASELINE_CEILING, + "batch operand string sites grew to {}; prefer structured claim slices", + metrics.batch_operand_string_sites + ); assert!( metrics.stage_local_helper_functions <= STAGE_HELPER_FUNCTION_BASELINE_CEILING, "stage-local helper function count grew to {}; factor verifier mechanics into shared runtime", @@ -427,6 +437,7 @@ fn verifier_cleanup_metrics(verifier_src: &Path) -> VerifierCleanupMetrics { metrics.stage_local_generic_plan_structs += count_stage_local_generic_plan_structs(&source); metrics.field_expr_operand_constants += count_field_expr_operand_constants(&source); + metrics.batch_operand_string_sites += count_batch_operand_string_sites(&source); metrics.stage_local_helper_functions += count_stage_local_helper_functions(&source); metrics.relation_string_sites += count_relation_string_sites(&source); } @@ -469,6 +480,13 @@ fn count_field_expr_operand_constants(source: &str) -> usize { .count() } +fn count_batch_operand_string_sites(source: &str) -> usize { + source + .lines() + .filter(|line| line.contains("ordered_claims: \"") || line.contains("claim_operands: \"")) + .count() +} + fn count_stage_local_helper_functions(source: &str) -> usize { const HELPER_PREFIXES: &[&str] = &[ "fn evaluate_stage", diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 1cecfcbf3b..30029afe6e 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -13,6 +13,12 @@ macro_rules! stage_list { }; } +macro_rules! stage_batch_list { + ($mode:ident, $values:expr) => { + super::leak_str_slice($values) + }; +} + macro_rules! stage_field_expr { (kernel, $module:ident, $field_expr:ident, $plan:ident) => { $module::$field_expr { @@ -457,8 +463,8 @@ macro_rules! define_stage_adapter_impl { proof_slot: super::leak_str(&plan.proof_slot), policy: super::leak_str(&plan.policy), count: plan.count, - ordered_claims: stage_list!($mode, &plan.ordered_claims), - claim_operands: stage_list!($mode, &plan.claim_operands), + ordered_claims: stage_batch_list!($mode, &plan.ordered_claims), + claim_operands: stage_batch_list!($mode, &plan.claim_operands), claim_label: super::leak_str(&plan.claim_label), round_label: super::leak_str(&plan.round_label), round_schedule: super::leak_usize_slice(&plan.round_schedule), @@ -580,8 +586,8 @@ macro_rules! define_stage_adapter_impl { proof_slot: super::leak_str(&plan.proof_slot), policy: super::leak_str(&plan.policy), count: plan.count, - ordered_claims: stage_list!($mode, &plan.ordered_claims), - claim_operands: stage_list!($mode, &plan.claim_operands), + ordered_claims: stage_batch_list!($mode, &plan.ordered_claims), + claim_operands: stage_batch_list!($mode, &plan.claim_operands), }) .collect(), ), @@ -768,8 +774,8 @@ macro_rules! define_stage1_adapter { proof_slot: super::leak_str(&plan.proof_slot), policy: super::leak_str(&plan.policy), count: plan.count, - ordered_claims: stage_list!($mode, &plan.ordered_claims), - claim_operands: stage_list!($mode, &plan.claim_operands), + ordered_claims: stage_batch_list!($mode, &plan.ordered_claims), + claim_operands: stage_batch_list!($mode, &plan.claim_operands), claim_label: super::leak_str(&plan.claim_label), round_label: super::leak_str(&plan.round_label), round_schedule: super::leak_usize_slice(&plan.round_schedule), @@ -839,8 +845,8 @@ macro_rules! define_stage1_adapter { proof_slot: super::leak_str(&plan.proof_slot), policy: super::leak_str(&plan.policy), count: plan.count, - ordered_claims: stage_list!($mode, &plan.ordered_claims), - claim_operands: stage_list!($mode, &plan.claim_operands), + ordered_claims: stage_batch_list!($mode, &plan.ordered_claims), + claim_operands: stage_batch_list!($mode, &plan.claim_operands), }) .collect(), ), diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs index 94bd830e85..0018ad477e 100644 --- a/crates/jolt-verifier/src/stages/common.rs +++ b/crates/jolt-verifier/src/stages/common.rs @@ -187,8 +187,8 @@ pub struct SumcheckBatchPlan { pub proof_slot: &'static str, pub policy: &'static str, pub count: usize, - pub ordered_claims: &'static str, - pub claim_operands: &'static str, + pub ordered_claims: &'static [&'static str], + pub claim_operands: &'static [&'static str], pub claim_label: &'static str, pub round_label: &'static str, pub round_schedule: &'static [usize], @@ -288,8 +288,8 @@ pub struct OpeningBatchPlan { pub proof_slot: &'static str, pub policy: &'static str, pub count: usize, - pub ordered_claims: &'static str, - pub claim_operands: &'static str, + pub ordered_claims: &'static [&'static str], + pub claim_operands: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -867,7 +867,10 @@ pub fn batch_claims<'a, C: SymbolPlan>( claims: &'a [C], batch: &SumcheckBatchPlan, ) -> Result, RuntimePlanError> { - symbol_list(batch.claim_operands) + batch + .claim_operands + .iter() + .copied() .map(|symbol| { find_plan(claims, symbol).ok_or(RuntimePlanError::MissingClaim { batch: batch.symbol, @@ -1822,7 +1825,7 @@ where }) .collect::>(); for batch in opening_batches { - for symbol in symbol_list(batch.claim_operands) { + for &symbol in batch.claim_operands { let claim = opening_claims .iter() .find(|claim| claim.symbol == symbol) diff --git a/crates/jolt-verifier/src/stages/stage1_outer.rs b/crates/jolt-verifier/src/stages/stage1_outer.rs index 01f22a230f..b05d6fc0f8 100644 --- a/crates/jolt-verifier/src/stages/stage1_outer.rs +++ b/crates/jolt-verifier/src/stages/stage1_outer.rs @@ -52,8 +52,8 @@ pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1]; pub const STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[17]; pub const STAGE1_SUMCHECK_BATCHES: &[Stage1SumcheckBatchPlan] = &[ - Stage1SumcheckBatchPlan { symbol: "stage1.uniskip.batch", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: "stage1.uniskip.input", claim_operands: "stage1.uniskip.input", claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, - Stage1SumcheckBatchPlan { symbol: "stage1.outer_remaining.batch", stage: "stage1", proof_slot: "stage1.sumcheck", policy: "jolt_core_front_loaded", count: 1, ordered_claims: "stage1.outer_remaining.input", claim_operands: "stage1.outer_remaining.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, + Stage1SumcheckBatchPlan { symbol: "stage1.uniskip.batch", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: &["stage1.uniskip.input"], claim_operands: &["stage1.uniskip.input"], claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage1SumcheckBatchPlan { symbol: "stage1.outer_remaining.batch", stage: "stage1", proof_slot: "stage1.sumcheck", policy: "jolt_core_front_loaded", count: 1, ordered_claims: &["stage1.outer_remaining.input"], claim_operands: &["stage1.outer_remaining.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, ]; pub const STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1]; @@ -147,7 +147,7 @@ pub const STAGE1_OPENING_CLAIMS: &[Stage1OpeningClaimPlan] = &[ ]; pub const STAGE1_OPENING_BATCHES: &[Stage1OpeningBatchPlan] = &[ - Stage1OpeningBatchPlan { symbol: "stage1.outer_remaining.openings", stage: "stage1", proof_slot: "stage1.virtual_openings", policy: "jolt_r1cs_input_order", count: 35, ordered_claims: "stage1.outer_remaining.opening.LeftInstructionInput|stage1.outer_remaining.opening.RightInstructionInput|stage1.outer_remaining.opening.Product|stage1.outer_remaining.opening.ShouldBranch|stage1.outer_remaining.opening.PC|stage1.outer_remaining.opening.UnexpandedPC|stage1.outer_remaining.opening.Imm|stage1.outer_remaining.opening.RamAddress|stage1.outer_remaining.opening.Rs1Value|stage1.outer_remaining.opening.Rs2Value|stage1.outer_remaining.opening.RdWriteValue|stage1.outer_remaining.opening.RamReadValue|stage1.outer_remaining.opening.RamWriteValue|stage1.outer_remaining.opening.LeftLookupOperand|stage1.outer_remaining.opening.RightLookupOperand|stage1.outer_remaining.opening.NextUnexpandedPC|stage1.outer_remaining.opening.NextPC|stage1.outer_remaining.opening.NextIsVirtual|stage1.outer_remaining.opening.NextIsFirstInSequence|stage1.outer_remaining.opening.LookupOutput|stage1.outer_remaining.opening.ShouldJump|stage1.outer_remaining.opening.OpFlagAddOperands|stage1.outer_remaining.opening.OpFlagSubtractOperands|stage1.outer_remaining.opening.OpFlagMultiplyOperands|stage1.outer_remaining.opening.OpFlagLoad|stage1.outer_remaining.opening.OpFlagStore|stage1.outer_remaining.opening.OpFlagJump|stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD|stage1.outer_remaining.opening.OpFlagVirtualInstruction|stage1.outer_remaining.opening.OpFlagAssert|stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC|stage1.outer_remaining.opening.OpFlagAdvice|stage1.outer_remaining.opening.OpFlagIsCompressed|stage1.outer_remaining.opening.OpFlagIsFirstInSequence|stage1.outer_remaining.opening.OpFlagIsLastInSequence", claim_operands: "stage1.outer_remaining.opening.LeftInstructionInput|stage1.outer_remaining.opening.RightInstructionInput|stage1.outer_remaining.opening.Product|stage1.outer_remaining.opening.ShouldBranch|stage1.outer_remaining.opening.PC|stage1.outer_remaining.opening.UnexpandedPC|stage1.outer_remaining.opening.Imm|stage1.outer_remaining.opening.RamAddress|stage1.outer_remaining.opening.Rs1Value|stage1.outer_remaining.opening.Rs2Value|stage1.outer_remaining.opening.RdWriteValue|stage1.outer_remaining.opening.RamReadValue|stage1.outer_remaining.opening.RamWriteValue|stage1.outer_remaining.opening.LeftLookupOperand|stage1.outer_remaining.opening.RightLookupOperand|stage1.outer_remaining.opening.NextUnexpandedPC|stage1.outer_remaining.opening.NextPC|stage1.outer_remaining.opening.NextIsVirtual|stage1.outer_remaining.opening.NextIsFirstInSequence|stage1.outer_remaining.opening.LookupOutput|stage1.outer_remaining.opening.ShouldJump|stage1.outer_remaining.opening.OpFlagAddOperands|stage1.outer_remaining.opening.OpFlagSubtractOperands|stage1.outer_remaining.opening.OpFlagMultiplyOperands|stage1.outer_remaining.opening.OpFlagLoad|stage1.outer_remaining.opening.OpFlagStore|stage1.outer_remaining.opening.OpFlagJump|stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD|stage1.outer_remaining.opening.OpFlagVirtualInstruction|stage1.outer_remaining.opening.OpFlagAssert|stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC|stage1.outer_remaining.opening.OpFlagAdvice|stage1.outer_remaining.opening.OpFlagIsCompressed|stage1.outer_remaining.opening.OpFlagIsFirstInSequence|stage1.outer_remaining.opening.OpFlagIsLastInSequence" }, + Stage1OpeningBatchPlan { symbol: "stage1.outer_remaining.openings", stage: "stage1", proof_slot: "stage1.virtual_openings", policy: "jolt_r1cs_input_order", count: 35, ordered_claims: &["stage1.outer_remaining.opening.LeftInstructionInput", "stage1.outer_remaining.opening.RightInstructionInput", "stage1.outer_remaining.opening.Product", "stage1.outer_remaining.opening.ShouldBranch", "stage1.outer_remaining.opening.PC", "stage1.outer_remaining.opening.UnexpandedPC", "stage1.outer_remaining.opening.Imm", "stage1.outer_remaining.opening.RamAddress", "stage1.outer_remaining.opening.Rs1Value", "stage1.outer_remaining.opening.Rs2Value", "stage1.outer_remaining.opening.RdWriteValue", "stage1.outer_remaining.opening.RamReadValue", "stage1.outer_remaining.opening.RamWriteValue", "stage1.outer_remaining.opening.LeftLookupOperand", "stage1.outer_remaining.opening.RightLookupOperand", "stage1.outer_remaining.opening.NextUnexpandedPC", "stage1.outer_remaining.opening.NextPC", "stage1.outer_remaining.opening.NextIsVirtual", "stage1.outer_remaining.opening.NextIsFirstInSequence", "stage1.outer_remaining.opening.LookupOutput", "stage1.outer_remaining.opening.ShouldJump", "stage1.outer_remaining.opening.OpFlagAddOperands", "stage1.outer_remaining.opening.OpFlagSubtractOperands", "stage1.outer_remaining.opening.OpFlagMultiplyOperands", "stage1.outer_remaining.opening.OpFlagLoad", "stage1.outer_remaining.opening.OpFlagStore", "stage1.outer_remaining.opening.OpFlagJump", "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", "stage1.outer_remaining.opening.OpFlagVirtualInstruction", "stage1.outer_remaining.opening.OpFlagAssert", "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", "stage1.outer_remaining.opening.OpFlagAdvice", "stage1.outer_remaining.opening.OpFlagIsCompressed", "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", "stage1.outer_remaining.opening.OpFlagIsLastInSequence"], claim_operands: &["stage1.outer_remaining.opening.LeftInstructionInput", "stage1.outer_remaining.opening.RightInstructionInput", "stage1.outer_remaining.opening.Product", "stage1.outer_remaining.opening.ShouldBranch", "stage1.outer_remaining.opening.PC", "stage1.outer_remaining.opening.UnexpandedPC", "stage1.outer_remaining.opening.Imm", "stage1.outer_remaining.opening.RamAddress", "stage1.outer_remaining.opening.Rs1Value", "stage1.outer_remaining.opening.Rs2Value", "stage1.outer_remaining.opening.RdWriteValue", "stage1.outer_remaining.opening.RamReadValue", "stage1.outer_remaining.opening.RamWriteValue", "stage1.outer_remaining.opening.LeftLookupOperand", "stage1.outer_remaining.opening.RightLookupOperand", "stage1.outer_remaining.opening.NextUnexpandedPC", "stage1.outer_remaining.opening.NextPC", "stage1.outer_remaining.opening.NextIsVirtual", "stage1.outer_remaining.opening.NextIsFirstInSequence", "stage1.outer_remaining.opening.LookupOutput", "stage1.outer_remaining.opening.ShouldJump", "stage1.outer_remaining.opening.OpFlagAddOperands", "stage1.outer_remaining.opening.OpFlagSubtractOperands", "stage1.outer_remaining.opening.OpFlagMultiplyOperands", "stage1.outer_remaining.opening.OpFlagLoad", "stage1.outer_remaining.opening.OpFlagStore", "stage1.outer_remaining.opening.OpFlagJump", "stage1.outer_remaining.opening.OpFlagWriteLookupOutputToRD", "stage1.outer_remaining.opening.OpFlagVirtualInstruction", "stage1.outer_remaining.opening.OpFlagAssert", "stage1.outer_remaining.opening.OpFlagDoNotUpdateUnexpandedPC", "stage1.outer_remaining.opening.OpFlagAdvice", "stage1.outer_remaining.opening.OpFlagIsCompressed", "stage1.outer_remaining.opening.OpFlagIsFirstInSequence", "stage1.outer_remaining.opening.OpFlagIsLastInSequence"] }, ]; pub const STAGE1_PROGRAM: Stage1VerifierProgramPlan = Stage1VerifierProgramPlan { params: STAGE1_PARAMS, diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index b6dc0090a2..c3ea7fb0d6 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -147,8 +147,8 @@ pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1]; pub const STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[16, 16]; pub const STAGE2_SUMCHECK_BATCHES: &[Stage2SumcheckBatchPlan] = &[ - Stage2SumcheckBatchPlan { symbol: "stage2.product_virtual.uniskip.batch", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: "stage2.product_virtual.uniskip.input", claim_operands: "stage2.product_virtual.uniskip.input", claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, - Stage2SumcheckBatchPlan { symbol: "stage2.batch", stage: "stage2", proof_slot: "stage2.sumcheck", policy: "jolt_core_stage2_aligned", count: 5, ordered_claims: "stage2.ram_read_write.input|stage2.product_virtual.remainder.input|stage2.instruction_lookup.claim_reduction.input|stage2.ram_raf.input|stage2.ram_output.input", claim_operands: "stage2.ram_read_write.input|stage2.product_virtual.remainder.input|stage2.instruction_lookup.claim_reduction.input|stage2.ram_raf.input|stage2.ram_output.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, + Stage2SumcheckBatchPlan { symbol: "stage2.product_virtual.uniskip.batch", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: &["stage2.product_virtual.uniskip.input"], claim_operands: &["stage2.product_virtual.uniskip.input"], claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage2SumcheckBatchPlan { symbol: "stage2.batch", stage: "stage2", proof_slot: "stage2.sumcheck", policy: "jolt_core_stage2_aligned", count: 5, ordered_claims: &["stage2.ram_read_write.input", "stage2.product_virtual.remainder.input", "stage2.instruction_lookup.claim_reduction.input", "stage2.ram_raf.input", "stage2.ram_output.input"], claim_operands: &["stage2.ram_read_write.input", "stage2.product_virtual.remainder.input", "stage2.instruction_lookup.claim_reduction.input", "stage2.ram_raf.input", "stage2.ram_output.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, ]; pub const STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1]; @@ -219,7 +219,7 @@ pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[ ]; pub const STAGE2_OPENING_BATCHES: &[Stage2OpeningBatchPlan] = &[ - Stage2OpeningBatchPlan { symbol: "stage2.openings", stage: "stage2", proof_slot: "stage2.openings", policy: "jolt_stage2_output_order", count: 18, ordered_claims: "stage2.ram_read_write.opening.RamVal|stage2.ram_read_write.opening.RamRa|stage2.ram_read_write.opening.RamInc|stage2.product_virtual.remainder.opening.LeftInstructionInput|stage2.product_virtual.remainder.opening.RightInstructionInput|stage2.product_virtual.remainder.opening.OpFlagJump|stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD|stage2.product_virtual.remainder.opening.LookupOutput|stage2.product_virtual.remainder.opening.InstructionFlagBranch|stage2.product_virtual.remainder.opening.NextIsNoop|stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction|stage2.instruction_lookup.claim_reduction.opening.LookupOutput|stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand|stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand|stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput|stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput|stage2.ram_raf.opening.RamRa|stage2.ram_output.opening.RamValFinal", claim_operands: "stage2.ram_read_write.opening.RamVal|stage2.ram_read_write.opening.RamRa|stage2.ram_read_write.opening.RamInc|stage2.product_virtual.remainder.opening.LeftInstructionInput|stage2.product_virtual.remainder.opening.RightInstructionInput|stage2.product_virtual.remainder.opening.OpFlagJump|stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD|stage2.product_virtual.remainder.opening.LookupOutput|stage2.product_virtual.remainder.opening.InstructionFlagBranch|stage2.product_virtual.remainder.opening.NextIsNoop|stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction|stage2.instruction_lookup.claim_reduction.opening.LookupOutput|stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand|stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand|stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput|stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput|stage2.ram_raf.opening.RamRa|stage2.ram_output.opening.RamValFinal" }, + Stage2OpeningBatchPlan { symbol: "stage2.openings", stage: "stage2", proof_slot: "stage2.openings", policy: "jolt_stage2_output_order", count: 18, ordered_claims: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"], claim_operands: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"] }, ]; pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan { params: STAGE2_PARAMS, @@ -586,7 +586,10 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, batch: &Stage2SumcheckBatchPlan, ) -> Result, VerifyStage2Error> { - super::common::symbol_list(batch.claim_operands) + batch + .claim_operands + .iter() + .copied() .map(|symbol| { let claim = find_plan(program.claims, symbol).ok_or(VerifyStage2Error::MissingClaim { batch: batch.symbol, diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index a9a012cf12..322745e58c 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -112,7 +112,7 @@ pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[ pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16]; pub const STAGE3_SUMCHECK_BATCHES: &[Stage3SumcheckBatchPlan] = &[ - Stage3SumcheckBatchPlan { symbol: "stage3.batch", stage: "stage3", proof_slot: "stage3.sumcheck", policy: "jolt_core_stage3_aligned", count: 3, ordered_claims: "stage3.spartan_shift.input|stage3.instruction_input.input|stage3.registers_claim_reduction.input", claim_operands: "stage3.spartan_shift.input|stage3.instruction_input.input|stage3.registers_claim_reduction.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage3SumcheckBatchPlan { symbol: "stage3.batch", stage: "stage3", proof_slot: "stage3.sumcheck", policy: "jolt_core_stage3_aligned", count: 3, ordered_claims: &["stage3.spartan_shift.input", "stage3.instruction_input.input", "stage3.registers_claim_reduction.input"], claim_operands: &["stage3.spartan_shift.input", "stage3.instruction_input.input", "stage3.registers_claim_reduction.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16]; @@ -176,7 +176,7 @@ pub const STAGE3_OPENING_EQUALITIES: &[Stage3OpeningClaimEqualityPlan] = &[ ]; pub const STAGE3_OPENING_BATCHES: &[Stage3OpeningBatchPlan] = &[ - Stage3OpeningBatchPlan { symbol: "stage3.openings", stage: "stage3", proof_slot: "stage3.openings", policy: "jolt_stage3_output_order", count: 16, ordered_claims: "stage3.spartan_shift.opening.UnexpandedPC|stage3.spartan_shift.opening.PC|stage3.spartan_shift.opening.OpFlagVirtualInstruction|stage3.spartan_shift.opening.OpFlagIsFirstInSequence|stage3.spartan_shift.opening.InstructionFlagIsNoop|stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value|stage3.instruction_input.opening.Rs1Value|stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC|stage3.instruction_input.opening.UnexpandedPC|stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value|stage3.instruction_input.opening.Rs2Value|stage3.instruction_input.opening.InstructionFlagRightOperandIsImm|stage3.instruction_input.opening.Imm|stage3.registers_claim_reduction.opening.RdWriteValue|stage3.registers_claim_reduction.opening.Rs1Value|stage3.registers_claim_reduction.opening.Rs2Value", claim_operands: "stage3.spartan_shift.opening.UnexpandedPC|stage3.spartan_shift.opening.PC|stage3.spartan_shift.opening.OpFlagVirtualInstruction|stage3.spartan_shift.opening.OpFlagIsFirstInSequence|stage3.spartan_shift.opening.InstructionFlagIsNoop|stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value|stage3.instruction_input.opening.Rs1Value|stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC|stage3.instruction_input.opening.UnexpandedPC|stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value|stage3.instruction_input.opening.Rs2Value|stage3.instruction_input.opening.InstructionFlagRightOperandIsImm|stage3.instruction_input.opening.Imm|stage3.registers_claim_reduction.opening.RdWriteValue|stage3.registers_claim_reduction.opening.Rs1Value|stage3.registers_claim_reduction.opening.Rs2Value" }, + Stage3OpeningBatchPlan { symbol: "stage3.openings", stage: "stage3", proof_slot: "stage3.openings", policy: "jolt_stage3_output_order", count: 16, ordered_claims: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"], claim_operands: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"] }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { params: STAGE3_PARAMS, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 9e0a3341bc..d1aca192d0 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -106,7 +106,7 @@ pub const STAGE4_SUMCHECK_CLAIMS: &[Stage4SumcheckClaimPlan] = &[ pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16, 7]; pub const STAGE4_SUMCHECK_BATCHES: &[Stage4SumcheckBatchPlan] = &[ - Stage4SumcheckBatchPlan { symbol: "stage4.batch", stage: "stage4", proof_slot: "stage4.sumcheck", policy: "jolt_core_stage4_aligned", count: 2, ordered_claims: "stage4.registers_read_write.input|stage4.ram_val_check.input", claim_operands: "stage4.registers_read_write.input|stage4.ram_val_check.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage4SumcheckBatchPlan { symbol: "stage4.batch", stage: "stage4", proof_slot: "stage4.sumcheck", policy: "jolt_core_stage4_aligned", count: 2, ordered_claims: &["stage4.registers_read_write.input", "stage4.ram_val_check.input"], claim_operands: &["stage4.registers_read_write.input", "stage4.ram_val_check.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16, 7]; @@ -152,7 +152,7 @@ pub const STAGE4_OPENING_EQUALITIES: &[Stage4OpeningClaimEqualityPlan] = &[ ]; pub const STAGE4_OPENING_BATCHES: &[Stage4OpeningBatchPlan] = &[ - Stage4OpeningBatchPlan { symbol: "stage4.openings", stage: "stage4", proof_slot: "stage4.openings", policy: "jolt_stage4_output_order", count: 7, ordered_claims: "stage4.registers_read_write.opening.RegistersVal|stage4.registers_read_write.opening.Rs1Ra|stage4.registers_read_write.opening.Rs2Ra|stage4.registers_read_write.opening.RdWa|stage4.registers_read_write.opening.RdInc|stage4.ram_val_check.opening.RamRa|stage4.ram_val_check.opening.RamInc", claim_operands: "stage4.registers_read_write.opening.RegistersVal|stage4.registers_read_write.opening.Rs1Ra|stage4.registers_read_write.opening.Rs2Ra|stage4.registers_read_write.opening.RdWa|stage4.registers_read_write.opening.RdInc|stage4.ram_val_check.opening.RamRa|stage4.ram_val_check.opening.RamInc" }, + Stage4OpeningBatchPlan { symbol: "stage4.openings", stage: "stage4", proof_slot: "stage4.openings", policy: "jolt_stage4_output_order", count: 7, ordered_claims: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"], claim_operands: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"] }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { role: "verifier", diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 1fdd30915c..d097646940 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -108,7 +108,7 @@ pub const STAGE5_SUMCHECK_CLAIMS: &[Stage5SumcheckClaimPlan] = &[ pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[128, 16]; pub const STAGE5_SUMCHECK_BATCHES: &[Stage5SumcheckBatchPlan] = &[ - Stage5SumcheckBatchPlan { symbol: "stage5.batch", stage: "stage5", proof_slot: "stage5.sumcheck", policy: "jolt_core_stage5_aligned", count: 3, ordered_claims: "stage5.instruction_read_raf.input|stage5.ram_ra_claim_reduction.input|stage5.registers_val_evaluation.input", claim_operands: "stage5.instruction_read_raf.input|stage5.ram_ra_claim_reduction.input|stage5.registers_val_evaluation.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage5SumcheckBatchPlan { symbol: "stage5.batch", stage: "stage5", proof_slot: "stage5.sumcheck", policy: "jolt_core_stage5_aligned", count: 3, ordered_claims: &["stage5.instruction_read_raf.input", "stage5.ram_ra_claim_reduction.input", "stage5.registers_val_evaluation.input"], claim_operands: &["stage5.instruction_read_raf.input", "stage5.ram_ra_claim_reduction.input", "stage5.registers_val_evaluation.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[128, 16]; @@ -264,7 +264,7 @@ pub const STAGE5_OPENING_EQUALITIES: &[Stage5OpeningClaimEqualityPlan] = &[ ]; pub const STAGE5_OPENING_BATCHES: &[Stage5OpeningBatchPlan] = &[ - Stage5OpeningBatchPlan { symbol: "stage5.openings", stage: "stage5", proof_slot: "stage5.openings", policy: "jolt_stage5_output_order", count: 53, ordered_claims: "stage5.instruction_read_raf.opening.LookupTableFlag_0|stage5.instruction_read_raf.opening.LookupTableFlag_1|stage5.instruction_read_raf.opening.LookupTableFlag_2|stage5.instruction_read_raf.opening.LookupTableFlag_3|stage5.instruction_read_raf.opening.LookupTableFlag_4|stage5.instruction_read_raf.opening.LookupTableFlag_5|stage5.instruction_read_raf.opening.LookupTableFlag_6|stage5.instruction_read_raf.opening.LookupTableFlag_7|stage5.instruction_read_raf.opening.LookupTableFlag_8|stage5.instruction_read_raf.opening.LookupTableFlag_9|stage5.instruction_read_raf.opening.LookupTableFlag_10|stage5.instruction_read_raf.opening.LookupTableFlag_11|stage5.instruction_read_raf.opening.LookupTableFlag_12|stage5.instruction_read_raf.opening.LookupTableFlag_13|stage5.instruction_read_raf.opening.LookupTableFlag_14|stage5.instruction_read_raf.opening.LookupTableFlag_15|stage5.instruction_read_raf.opening.LookupTableFlag_16|stage5.instruction_read_raf.opening.LookupTableFlag_17|stage5.instruction_read_raf.opening.LookupTableFlag_18|stage5.instruction_read_raf.opening.LookupTableFlag_19|stage5.instruction_read_raf.opening.LookupTableFlag_20|stage5.instruction_read_raf.opening.LookupTableFlag_21|stage5.instruction_read_raf.opening.LookupTableFlag_22|stage5.instruction_read_raf.opening.LookupTableFlag_23|stage5.instruction_read_raf.opening.LookupTableFlag_24|stage5.instruction_read_raf.opening.LookupTableFlag_25|stage5.instruction_read_raf.opening.LookupTableFlag_26|stage5.instruction_read_raf.opening.LookupTableFlag_27|stage5.instruction_read_raf.opening.LookupTableFlag_28|stage5.instruction_read_raf.opening.LookupTableFlag_29|stage5.instruction_read_raf.opening.LookupTableFlag_30|stage5.instruction_read_raf.opening.LookupTableFlag_31|stage5.instruction_read_raf.opening.LookupTableFlag_32|stage5.instruction_read_raf.opening.LookupTableFlag_33|stage5.instruction_read_raf.opening.LookupTableFlag_34|stage5.instruction_read_raf.opening.LookupTableFlag_35|stage5.instruction_read_raf.opening.LookupTableFlag_36|stage5.instruction_read_raf.opening.LookupTableFlag_37|stage5.instruction_read_raf.opening.LookupTableFlag_38|stage5.instruction_read_raf.opening.LookupTableFlag_39|stage5.instruction_read_raf.opening.LookupTableFlag_40|stage5.instruction_read_raf.opening.InstructionRa_0|stage5.instruction_read_raf.opening.InstructionRa_1|stage5.instruction_read_raf.opening.InstructionRa_2|stage5.instruction_read_raf.opening.InstructionRa_3|stage5.instruction_read_raf.opening.InstructionRa_4|stage5.instruction_read_raf.opening.InstructionRa_5|stage5.instruction_read_raf.opening.InstructionRa_6|stage5.instruction_read_raf.opening.InstructionRa_7|stage5.instruction_read_raf.opening.InstructionRafFlag|stage5.ram_ra_claim_reduction.opening.RamRa|stage5.registers_val_evaluation.opening.RdInc|stage5.registers_val_evaluation.opening.RdWa", claim_operands: "stage5.instruction_read_raf.opening.LookupTableFlag_0|stage5.instruction_read_raf.opening.LookupTableFlag_1|stage5.instruction_read_raf.opening.LookupTableFlag_2|stage5.instruction_read_raf.opening.LookupTableFlag_3|stage5.instruction_read_raf.opening.LookupTableFlag_4|stage5.instruction_read_raf.opening.LookupTableFlag_5|stage5.instruction_read_raf.opening.LookupTableFlag_6|stage5.instruction_read_raf.opening.LookupTableFlag_7|stage5.instruction_read_raf.opening.LookupTableFlag_8|stage5.instruction_read_raf.opening.LookupTableFlag_9|stage5.instruction_read_raf.opening.LookupTableFlag_10|stage5.instruction_read_raf.opening.LookupTableFlag_11|stage5.instruction_read_raf.opening.LookupTableFlag_12|stage5.instruction_read_raf.opening.LookupTableFlag_13|stage5.instruction_read_raf.opening.LookupTableFlag_14|stage5.instruction_read_raf.opening.LookupTableFlag_15|stage5.instruction_read_raf.opening.LookupTableFlag_16|stage5.instruction_read_raf.opening.LookupTableFlag_17|stage5.instruction_read_raf.opening.LookupTableFlag_18|stage5.instruction_read_raf.opening.LookupTableFlag_19|stage5.instruction_read_raf.opening.LookupTableFlag_20|stage5.instruction_read_raf.opening.LookupTableFlag_21|stage5.instruction_read_raf.opening.LookupTableFlag_22|stage5.instruction_read_raf.opening.LookupTableFlag_23|stage5.instruction_read_raf.opening.LookupTableFlag_24|stage5.instruction_read_raf.opening.LookupTableFlag_25|stage5.instruction_read_raf.opening.LookupTableFlag_26|stage5.instruction_read_raf.opening.LookupTableFlag_27|stage5.instruction_read_raf.opening.LookupTableFlag_28|stage5.instruction_read_raf.opening.LookupTableFlag_29|stage5.instruction_read_raf.opening.LookupTableFlag_30|stage5.instruction_read_raf.opening.LookupTableFlag_31|stage5.instruction_read_raf.opening.LookupTableFlag_32|stage5.instruction_read_raf.opening.LookupTableFlag_33|stage5.instruction_read_raf.opening.LookupTableFlag_34|stage5.instruction_read_raf.opening.LookupTableFlag_35|stage5.instruction_read_raf.opening.LookupTableFlag_36|stage5.instruction_read_raf.opening.LookupTableFlag_37|stage5.instruction_read_raf.opening.LookupTableFlag_38|stage5.instruction_read_raf.opening.LookupTableFlag_39|stage5.instruction_read_raf.opening.LookupTableFlag_40|stage5.instruction_read_raf.opening.InstructionRa_0|stage5.instruction_read_raf.opening.InstructionRa_1|stage5.instruction_read_raf.opening.InstructionRa_2|stage5.instruction_read_raf.opening.InstructionRa_3|stage5.instruction_read_raf.opening.InstructionRa_4|stage5.instruction_read_raf.opening.InstructionRa_5|stage5.instruction_read_raf.opening.InstructionRa_6|stage5.instruction_read_raf.opening.InstructionRa_7|stage5.instruction_read_raf.opening.InstructionRafFlag|stage5.ram_ra_claim_reduction.opening.RamRa|stage5.registers_val_evaluation.opening.RdInc|stage5.registers_val_evaluation.opening.RdWa" }, + Stage5OpeningBatchPlan { symbol: "stage5.openings", stage: "stage5", proof_slot: "stage5.openings", policy: "jolt_stage5_output_order", count: 53, ordered_claims: &["stage5.instruction_read_raf.opening.LookupTableFlag_0", "stage5.instruction_read_raf.opening.LookupTableFlag_1", "stage5.instruction_read_raf.opening.LookupTableFlag_2", "stage5.instruction_read_raf.opening.LookupTableFlag_3", "stage5.instruction_read_raf.opening.LookupTableFlag_4", "stage5.instruction_read_raf.opening.LookupTableFlag_5", "stage5.instruction_read_raf.opening.LookupTableFlag_6", "stage5.instruction_read_raf.opening.LookupTableFlag_7", "stage5.instruction_read_raf.opening.LookupTableFlag_8", "stage5.instruction_read_raf.opening.LookupTableFlag_9", "stage5.instruction_read_raf.opening.LookupTableFlag_10", "stage5.instruction_read_raf.opening.LookupTableFlag_11", "stage5.instruction_read_raf.opening.LookupTableFlag_12", "stage5.instruction_read_raf.opening.LookupTableFlag_13", "stage5.instruction_read_raf.opening.LookupTableFlag_14", "stage5.instruction_read_raf.opening.LookupTableFlag_15", "stage5.instruction_read_raf.opening.LookupTableFlag_16", "stage5.instruction_read_raf.opening.LookupTableFlag_17", "stage5.instruction_read_raf.opening.LookupTableFlag_18", "stage5.instruction_read_raf.opening.LookupTableFlag_19", "stage5.instruction_read_raf.opening.LookupTableFlag_20", "stage5.instruction_read_raf.opening.LookupTableFlag_21", "stage5.instruction_read_raf.opening.LookupTableFlag_22", "stage5.instruction_read_raf.opening.LookupTableFlag_23", "stage5.instruction_read_raf.opening.LookupTableFlag_24", "stage5.instruction_read_raf.opening.LookupTableFlag_25", "stage5.instruction_read_raf.opening.LookupTableFlag_26", "stage5.instruction_read_raf.opening.LookupTableFlag_27", "stage5.instruction_read_raf.opening.LookupTableFlag_28", "stage5.instruction_read_raf.opening.LookupTableFlag_29", "stage5.instruction_read_raf.opening.LookupTableFlag_30", "stage5.instruction_read_raf.opening.LookupTableFlag_31", "stage5.instruction_read_raf.opening.LookupTableFlag_32", "stage5.instruction_read_raf.opening.LookupTableFlag_33", "stage5.instruction_read_raf.opening.LookupTableFlag_34", "stage5.instruction_read_raf.opening.LookupTableFlag_35", "stage5.instruction_read_raf.opening.LookupTableFlag_36", "stage5.instruction_read_raf.opening.LookupTableFlag_37", "stage5.instruction_read_raf.opening.LookupTableFlag_38", "stage5.instruction_read_raf.opening.LookupTableFlag_39", "stage5.instruction_read_raf.opening.LookupTableFlag_40", "stage5.instruction_read_raf.opening.InstructionRa_0", "stage5.instruction_read_raf.opening.InstructionRa_1", "stage5.instruction_read_raf.opening.InstructionRa_2", "stage5.instruction_read_raf.opening.InstructionRa_3", "stage5.instruction_read_raf.opening.InstructionRa_4", "stage5.instruction_read_raf.opening.InstructionRa_5", "stage5.instruction_read_raf.opening.InstructionRa_6", "stage5.instruction_read_raf.opening.InstructionRa_7", "stage5.instruction_read_raf.opening.InstructionRafFlag", "stage5.ram_ra_claim_reduction.opening.RamRa", "stage5.registers_val_evaluation.opening.RdInc", "stage5.registers_val_evaluation.opening.RdWa"], claim_operands: &["stage5.instruction_read_raf.opening.LookupTableFlag_0", "stage5.instruction_read_raf.opening.LookupTableFlag_1", "stage5.instruction_read_raf.opening.LookupTableFlag_2", "stage5.instruction_read_raf.opening.LookupTableFlag_3", "stage5.instruction_read_raf.opening.LookupTableFlag_4", "stage5.instruction_read_raf.opening.LookupTableFlag_5", "stage5.instruction_read_raf.opening.LookupTableFlag_6", "stage5.instruction_read_raf.opening.LookupTableFlag_7", "stage5.instruction_read_raf.opening.LookupTableFlag_8", "stage5.instruction_read_raf.opening.LookupTableFlag_9", "stage5.instruction_read_raf.opening.LookupTableFlag_10", "stage5.instruction_read_raf.opening.LookupTableFlag_11", "stage5.instruction_read_raf.opening.LookupTableFlag_12", "stage5.instruction_read_raf.opening.LookupTableFlag_13", "stage5.instruction_read_raf.opening.LookupTableFlag_14", "stage5.instruction_read_raf.opening.LookupTableFlag_15", "stage5.instruction_read_raf.opening.LookupTableFlag_16", "stage5.instruction_read_raf.opening.LookupTableFlag_17", "stage5.instruction_read_raf.opening.LookupTableFlag_18", "stage5.instruction_read_raf.opening.LookupTableFlag_19", "stage5.instruction_read_raf.opening.LookupTableFlag_20", "stage5.instruction_read_raf.opening.LookupTableFlag_21", "stage5.instruction_read_raf.opening.LookupTableFlag_22", "stage5.instruction_read_raf.opening.LookupTableFlag_23", "stage5.instruction_read_raf.opening.LookupTableFlag_24", "stage5.instruction_read_raf.opening.LookupTableFlag_25", "stage5.instruction_read_raf.opening.LookupTableFlag_26", "stage5.instruction_read_raf.opening.LookupTableFlag_27", "stage5.instruction_read_raf.opening.LookupTableFlag_28", "stage5.instruction_read_raf.opening.LookupTableFlag_29", "stage5.instruction_read_raf.opening.LookupTableFlag_30", "stage5.instruction_read_raf.opening.LookupTableFlag_31", "stage5.instruction_read_raf.opening.LookupTableFlag_32", "stage5.instruction_read_raf.opening.LookupTableFlag_33", "stage5.instruction_read_raf.opening.LookupTableFlag_34", "stage5.instruction_read_raf.opening.LookupTableFlag_35", "stage5.instruction_read_raf.opening.LookupTableFlag_36", "stage5.instruction_read_raf.opening.LookupTableFlag_37", "stage5.instruction_read_raf.opening.LookupTableFlag_38", "stage5.instruction_read_raf.opening.LookupTableFlag_39", "stage5.instruction_read_raf.opening.LookupTableFlag_40", "stage5.instruction_read_raf.opening.InstructionRa_0", "stage5.instruction_read_raf.opening.InstructionRa_1", "stage5.instruction_read_raf.opening.InstructionRa_2", "stage5.instruction_read_raf.opening.InstructionRa_3", "stage5.instruction_read_raf.opening.InstructionRa_4", "stage5.instruction_read_raf.opening.InstructionRa_5", "stage5.instruction_read_raf.opening.InstructionRa_6", "stage5.instruction_read_raf.opening.InstructionRa_7", "stage5.instruction_read_raf.opening.InstructionRafFlag", "stage5.ram_ra_claim_reduction.opening.RamRa", "stage5.registers_val_evaluation.opening.RdInc", "stage5.registers_val_evaluation.opening.RdWa"] }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { role: "verifier", diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 6a891d1432..5deb289bce 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -361,7 +361,7 @@ pub const STAGE6_SUMCHECK_CLAIMS: &[Stage6SumcheckClaimPlan] = &[ pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[10, 16]; pub const STAGE6_SUMCHECK_BATCHES: &[Stage6SumcheckBatchPlan] = &[ - Stage6SumcheckBatchPlan { symbol: "stage6.batch", stage: "stage6", proof_slot: "stage6.sumcheck", policy: "jolt_core_stage6_aligned", count: 6, ordered_claims: "stage6.bytecode_read_raf.input|stage6.booleanity.input|stage6.hamming_booleanity.input|stage6.ram_ra_virtual.input|stage6.instruction_ra_virtual.input|stage6.inc_claim_reduction.input", claim_operands: "stage6.bytecode_read_raf.input|stage6.booleanity.input|stage6.hamming_booleanity.input|stage6.ram_ra_virtual.input|stage6.instruction_ra_virtual.input|stage6.inc_claim_reduction.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage6SumcheckBatchPlan { symbol: "stage6.batch", stage: "stage6", proof_slot: "stage6.sumcheck", policy: "jolt_core_stage6_aligned", count: 6, ordered_claims: &["stage6.bytecode_read_raf.input", "stage6.booleanity.input", "stage6.hamming_booleanity.input", "stage6.ram_ra_virtual.input", "stage6.instruction_ra_virtual.input", "stage6.inc_claim_reduction.input"], claim_operands: &["stage6.bytecode_read_raf.input", "stage6.booleanity.input", "stage6.hamming_booleanity.input", "stage6.ram_ra_virtual.input", "stage6.instruction_ra_virtual.input", "stage6.inc_claim_reduction.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[10, 16]; @@ -586,7 +586,7 @@ pub const STAGE6_OPENING_EQUALITIES: &[Stage6OpeningClaimEqualityPlan] = &[ ]; pub const STAGE6_OPENING_BATCHES: &[Stage6OpeningBatchPlan] = &[ - Stage6OpeningBatchPlan { symbol: "stage6.openings", stage: "stage6", proof_slot: "stage6.openings", policy: "jolt_stage6_output_order", count: 81, ordered_claims: "stage6.bytecode_read_raf.opening.BytecodeRa_0|stage6.bytecode_read_raf.opening.BytecodeRa_1|stage6.bytecode_read_raf.opening.BytecodeRa_2|stage6.booleanity.opening.InstructionRa_0|stage6.booleanity.opening.InstructionRa_1|stage6.booleanity.opening.InstructionRa_2|stage6.booleanity.opening.InstructionRa_3|stage6.booleanity.opening.InstructionRa_4|stage6.booleanity.opening.InstructionRa_5|stage6.booleanity.opening.InstructionRa_6|stage6.booleanity.opening.InstructionRa_7|stage6.booleanity.opening.InstructionRa_8|stage6.booleanity.opening.InstructionRa_9|stage6.booleanity.opening.InstructionRa_10|stage6.booleanity.opening.InstructionRa_11|stage6.booleanity.opening.InstructionRa_12|stage6.booleanity.opening.InstructionRa_13|stage6.booleanity.opening.InstructionRa_14|stage6.booleanity.opening.InstructionRa_15|stage6.booleanity.opening.InstructionRa_16|stage6.booleanity.opening.InstructionRa_17|stage6.booleanity.opening.InstructionRa_18|stage6.booleanity.opening.InstructionRa_19|stage6.booleanity.opening.InstructionRa_20|stage6.booleanity.opening.InstructionRa_21|stage6.booleanity.opening.InstructionRa_22|stage6.booleanity.opening.InstructionRa_23|stage6.booleanity.opening.InstructionRa_24|stage6.booleanity.opening.InstructionRa_25|stage6.booleanity.opening.InstructionRa_26|stage6.booleanity.opening.InstructionRa_27|stage6.booleanity.opening.InstructionRa_28|stage6.booleanity.opening.InstructionRa_29|stage6.booleanity.opening.InstructionRa_30|stage6.booleanity.opening.InstructionRa_31|stage6.booleanity.opening.BytecodeRa_0|stage6.booleanity.opening.BytecodeRa_1|stage6.booleanity.opening.BytecodeRa_2|stage6.booleanity.opening.RamRa_0|stage6.booleanity.opening.RamRa_1|stage6.booleanity.opening.RamRa_2|stage6.booleanity.opening.RamRa_3|stage6.hamming_booleanity.opening.HammingWeight|stage6.ram_ra_virtual.opening.RamRa_0|stage6.ram_ra_virtual.opening.RamRa_1|stage6.ram_ra_virtual.opening.RamRa_2|stage6.ram_ra_virtual.opening.RamRa_3|stage6.instruction_ra_virtual.opening.InstructionRa_0|stage6.instruction_ra_virtual.opening.InstructionRa_1|stage6.instruction_ra_virtual.opening.InstructionRa_2|stage6.instruction_ra_virtual.opening.InstructionRa_3|stage6.instruction_ra_virtual.opening.InstructionRa_4|stage6.instruction_ra_virtual.opening.InstructionRa_5|stage6.instruction_ra_virtual.opening.InstructionRa_6|stage6.instruction_ra_virtual.opening.InstructionRa_7|stage6.instruction_ra_virtual.opening.InstructionRa_8|stage6.instruction_ra_virtual.opening.InstructionRa_9|stage6.instruction_ra_virtual.opening.InstructionRa_10|stage6.instruction_ra_virtual.opening.InstructionRa_11|stage6.instruction_ra_virtual.opening.InstructionRa_12|stage6.instruction_ra_virtual.opening.InstructionRa_13|stage6.instruction_ra_virtual.opening.InstructionRa_14|stage6.instruction_ra_virtual.opening.InstructionRa_15|stage6.instruction_ra_virtual.opening.InstructionRa_16|stage6.instruction_ra_virtual.opening.InstructionRa_17|stage6.instruction_ra_virtual.opening.InstructionRa_18|stage6.instruction_ra_virtual.opening.InstructionRa_19|stage6.instruction_ra_virtual.opening.InstructionRa_20|stage6.instruction_ra_virtual.opening.InstructionRa_21|stage6.instruction_ra_virtual.opening.InstructionRa_22|stage6.instruction_ra_virtual.opening.InstructionRa_23|stage6.instruction_ra_virtual.opening.InstructionRa_24|stage6.instruction_ra_virtual.opening.InstructionRa_25|stage6.instruction_ra_virtual.opening.InstructionRa_26|stage6.instruction_ra_virtual.opening.InstructionRa_27|stage6.instruction_ra_virtual.opening.InstructionRa_28|stage6.instruction_ra_virtual.opening.InstructionRa_29|stage6.instruction_ra_virtual.opening.InstructionRa_30|stage6.instruction_ra_virtual.opening.InstructionRa_31|stage6.inc_claim_reduction.opening.RamInc|stage6.inc_claim_reduction.opening.RdInc", claim_operands: "stage6.bytecode_read_raf.opening.BytecodeRa_0|stage6.bytecode_read_raf.opening.BytecodeRa_1|stage6.bytecode_read_raf.opening.BytecodeRa_2|stage6.booleanity.opening.InstructionRa_0|stage6.booleanity.opening.InstructionRa_1|stage6.booleanity.opening.InstructionRa_2|stage6.booleanity.opening.InstructionRa_3|stage6.booleanity.opening.InstructionRa_4|stage6.booleanity.opening.InstructionRa_5|stage6.booleanity.opening.InstructionRa_6|stage6.booleanity.opening.InstructionRa_7|stage6.booleanity.opening.InstructionRa_8|stage6.booleanity.opening.InstructionRa_9|stage6.booleanity.opening.InstructionRa_10|stage6.booleanity.opening.InstructionRa_11|stage6.booleanity.opening.InstructionRa_12|stage6.booleanity.opening.InstructionRa_13|stage6.booleanity.opening.InstructionRa_14|stage6.booleanity.opening.InstructionRa_15|stage6.booleanity.opening.InstructionRa_16|stage6.booleanity.opening.InstructionRa_17|stage6.booleanity.opening.InstructionRa_18|stage6.booleanity.opening.InstructionRa_19|stage6.booleanity.opening.InstructionRa_20|stage6.booleanity.opening.InstructionRa_21|stage6.booleanity.opening.InstructionRa_22|stage6.booleanity.opening.InstructionRa_23|stage6.booleanity.opening.InstructionRa_24|stage6.booleanity.opening.InstructionRa_25|stage6.booleanity.opening.InstructionRa_26|stage6.booleanity.opening.InstructionRa_27|stage6.booleanity.opening.InstructionRa_28|stage6.booleanity.opening.InstructionRa_29|stage6.booleanity.opening.InstructionRa_30|stage6.booleanity.opening.InstructionRa_31|stage6.booleanity.opening.BytecodeRa_0|stage6.booleanity.opening.BytecodeRa_1|stage6.booleanity.opening.BytecodeRa_2|stage6.booleanity.opening.RamRa_0|stage6.booleanity.opening.RamRa_1|stage6.booleanity.opening.RamRa_2|stage6.booleanity.opening.RamRa_3|stage6.hamming_booleanity.opening.HammingWeight|stage6.ram_ra_virtual.opening.RamRa_0|stage6.ram_ra_virtual.opening.RamRa_1|stage6.ram_ra_virtual.opening.RamRa_2|stage6.ram_ra_virtual.opening.RamRa_3|stage6.instruction_ra_virtual.opening.InstructionRa_0|stage6.instruction_ra_virtual.opening.InstructionRa_1|stage6.instruction_ra_virtual.opening.InstructionRa_2|stage6.instruction_ra_virtual.opening.InstructionRa_3|stage6.instruction_ra_virtual.opening.InstructionRa_4|stage6.instruction_ra_virtual.opening.InstructionRa_5|stage6.instruction_ra_virtual.opening.InstructionRa_6|stage6.instruction_ra_virtual.opening.InstructionRa_7|stage6.instruction_ra_virtual.opening.InstructionRa_8|stage6.instruction_ra_virtual.opening.InstructionRa_9|stage6.instruction_ra_virtual.opening.InstructionRa_10|stage6.instruction_ra_virtual.opening.InstructionRa_11|stage6.instruction_ra_virtual.opening.InstructionRa_12|stage6.instruction_ra_virtual.opening.InstructionRa_13|stage6.instruction_ra_virtual.opening.InstructionRa_14|stage6.instruction_ra_virtual.opening.InstructionRa_15|stage6.instruction_ra_virtual.opening.InstructionRa_16|stage6.instruction_ra_virtual.opening.InstructionRa_17|stage6.instruction_ra_virtual.opening.InstructionRa_18|stage6.instruction_ra_virtual.opening.InstructionRa_19|stage6.instruction_ra_virtual.opening.InstructionRa_20|stage6.instruction_ra_virtual.opening.InstructionRa_21|stage6.instruction_ra_virtual.opening.InstructionRa_22|stage6.instruction_ra_virtual.opening.InstructionRa_23|stage6.instruction_ra_virtual.opening.InstructionRa_24|stage6.instruction_ra_virtual.opening.InstructionRa_25|stage6.instruction_ra_virtual.opening.InstructionRa_26|stage6.instruction_ra_virtual.opening.InstructionRa_27|stage6.instruction_ra_virtual.opening.InstructionRa_28|stage6.instruction_ra_virtual.opening.InstructionRa_29|stage6.instruction_ra_virtual.opening.InstructionRa_30|stage6.instruction_ra_virtual.opening.InstructionRa_31|stage6.inc_claim_reduction.opening.RamInc|stage6.inc_claim_reduction.opening.RdInc" }, + Stage6OpeningBatchPlan { symbol: "stage6.openings", stage: "stage6", proof_slot: "stage6.openings", policy: "jolt_stage6_output_order", count: 81, ordered_claims: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"], claim_operands: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"] }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { role: "verifier", diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 9d88207e1b..6a26103e9d 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -215,7 +215,7 @@ pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[ pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[ - Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, ordered_claims: "stage7.hamming_weight_claim_reduction.input", claim_operands: "stage7.hamming_weight_claim_reduction.input", claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, ordered_claims: &["stage7.hamming_weight_claim_reduction.input"], claim_operands: &["stage7.hamming_weight_claim_reduction.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4]; @@ -304,7 +304,7 @@ pub const STAGE7_OPENING_EQUALITIES: &[Stage7OpeningClaimEqualityPlan] = &[ ]; pub const STAGE7_OPENING_BATCHES: &[Stage7OpeningBatchPlan] = &[ - Stage7OpeningBatchPlan { symbol: "stage7.openings", stage: "stage7", proof_slot: "stage7.openings", policy: "jolt_stage7_output_order", count: 39, ordered_claims: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_0|stage7.hamming_weight_claim_reduction.opening.InstructionRa_1|stage7.hamming_weight_claim_reduction.opening.InstructionRa_2|stage7.hamming_weight_claim_reduction.opening.InstructionRa_3|stage7.hamming_weight_claim_reduction.opening.InstructionRa_4|stage7.hamming_weight_claim_reduction.opening.InstructionRa_5|stage7.hamming_weight_claim_reduction.opening.InstructionRa_6|stage7.hamming_weight_claim_reduction.opening.InstructionRa_7|stage7.hamming_weight_claim_reduction.opening.InstructionRa_8|stage7.hamming_weight_claim_reduction.opening.InstructionRa_9|stage7.hamming_weight_claim_reduction.opening.InstructionRa_10|stage7.hamming_weight_claim_reduction.opening.InstructionRa_11|stage7.hamming_weight_claim_reduction.opening.InstructionRa_12|stage7.hamming_weight_claim_reduction.opening.InstructionRa_13|stage7.hamming_weight_claim_reduction.opening.InstructionRa_14|stage7.hamming_weight_claim_reduction.opening.InstructionRa_15|stage7.hamming_weight_claim_reduction.opening.InstructionRa_16|stage7.hamming_weight_claim_reduction.opening.InstructionRa_17|stage7.hamming_weight_claim_reduction.opening.InstructionRa_18|stage7.hamming_weight_claim_reduction.opening.InstructionRa_19|stage7.hamming_weight_claim_reduction.opening.InstructionRa_20|stage7.hamming_weight_claim_reduction.opening.InstructionRa_21|stage7.hamming_weight_claim_reduction.opening.InstructionRa_22|stage7.hamming_weight_claim_reduction.opening.InstructionRa_23|stage7.hamming_weight_claim_reduction.opening.InstructionRa_24|stage7.hamming_weight_claim_reduction.opening.InstructionRa_25|stage7.hamming_weight_claim_reduction.opening.InstructionRa_26|stage7.hamming_weight_claim_reduction.opening.InstructionRa_27|stage7.hamming_weight_claim_reduction.opening.InstructionRa_28|stage7.hamming_weight_claim_reduction.opening.InstructionRa_29|stage7.hamming_weight_claim_reduction.opening.InstructionRa_30|stage7.hamming_weight_claim_reduction.opening.InstructionRa_31|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2|stage7.hamming_weight_claim_reduction.opening.RamRa_0|stage7.hamming_weight_claim_reduction.opening.RamRa_1|stage7.hamming_weight_claim_reduction.opening.RamRa_2|stage7.hamming_weight_claim_reduction.opening.RamRa_3", claim_operands: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_0|stage7.hamming_weight_claim_reduction.opening.InstructionRa_1|stage7.hamming_weight_claim_reduction.opening.InstructionRa_2|stage7.hamming_weight_claim_reduction.opening.InstructionRa_3|stage7.hamming_weight_claim_reduction.opening.InstructionRa_4|stage7.hamming_weight_claim_reduction.opening.InstructionRa_5|stage7.hamming_weight_claim_reduction.opening.InstructionRa_6|stage7.hamming_weight_claim_reduction.opening.InstructionRa_7|stage7.hamming_weight_claim_reduction.opening.InstructionRa_8|stage7.hamming_weight_claim_reduction.opening.InstructionRa_9|stage7.hamming_weight_claim_reduction.opening.InstructionRa_10|stage7.hamming_weight_claim_reduction.opening.InstructionRa_11|stage7.hamming_weight_claim_reduction.opening.InstructionRa_12|stage7.hamming_weight_claim_reduction.opening.InstructionRa_13|stage7.hamming_weight_claim_reduction.opening.InstructionRa_14|stage7.hamming_weight_claim_reduction.opening.InstructionRa_15|stage7.hamming_weight_claim_reduction.opening.InstructionRa_16|stage7.hamming_weight_claim_reduction.opening.InstructionRa_17|stage7.hamming_weight_claim_reduction.opening.InstructionRa_18|stage7.hamming_weight_claim_reduction.opening.InstructionRa_19|stage7.hamming_weight_claim_reduction.opening.InstructionRa_20|stage7.hamming_weight_claim_reduction.opening.InstructionRa_21|stage7.hamming_weight_claim_reduction.opening.InstructionRa_22|stage7.hamming_weight_claim_reduction.opening.InstructionRa_23|stage7.hamming_weight_claim_reduction.opening.InstructionRa_24|stage7.hamming_weight_claim_reduction.opening.InstructionRa_25|stage7.hamming_weight_claim_reduction.opening.InstructionRa_26|stage7.hamming_weight_claim_reduction.opening.InstructionRa_27|stage7.hamming_weight_claim_reduction.opening.InstructionRa_28|stage7.hamming_weight_claim_reduction.opening.InstructionRa_29|stage7.hamming_weight_claim_reduction.opening.InstructionRa_30|stage7.hamming_weight_claim_reduction.opening.InstructionRa_31|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1|stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2|stage7.hamming_weight_claim_reduction.opening.RamRa_0|stage7.hamming_weight_claim_reduction.opening.RamRa_1|stage7.hamming_weight_claim_reduction.opening.RamRa_2|stage7.hamming_weight_claim_reduction.opening.RamRa_3" }, + Stage7OpeningBatchPlan { symbol: "stage7.openings", stage: "stage7", proof_slot: "stage7.openings", policy: "jolt_stage7_output_order", count: 39, ordered_claims: &["stage7.hamming_weight_claim_reduction.opening.InstructionRa_0", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_1", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_2", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_3", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_4", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_5", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_6", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_7", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_8", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_9", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_10", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_11", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_12", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_13", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_14", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_15", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_16", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_17", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_18", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_19", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_20", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_21", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_22", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_23", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_24", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_25", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_26", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_27", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_28", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_29", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_30", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_31", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.opening.RamRa_0", "stage7.hamming_weight_claim_reduction.opening.RamRa_1", "stage7.hamming_weight_claim_reduction.opening.RamRa_2", "stage7.hamming_weight_claim_reduction.opening.RamRa_3"], claim_operands: &["stage7.hamming_weight_claim_reduction.opening.InstructionRa_0", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_1", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_2", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_3", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_4", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_5", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_6", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_7", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_8", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_9", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_10", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_11", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_12", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_13", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_14", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_15", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_16", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_17", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_18", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_19", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_20", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_21", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_22", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_23", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_24", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_25", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_26", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_27", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_28", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_29", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_30", "stage7.hamming_weight_claim_reduction.opening.InstructionRa_31", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.opening.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.opening.RamRa_0", "stage7.hamming_weight_claim_reduction.opening.RamRa_1", "stage7.hamming_weight_claim_reduction.opening.RamRa_2", "stage7.hamming_weight_claim_reduction.opening.RamRa_3"] }, ]; pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan { role: "verifier", From 130ce6033b49cd7219a13b26d0f38f3c85b343a4 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 18:57:41 -0600 Subject: [PATCH 007/171] refactor(bolt): structure verifier claim inputs --- .../src/protocols/jolt/emit/rust/stage1.rs | 2 +- .../src/protocols/jolt/emit/rust/stage2.rs | 2 +- .../src/protocols/jolt/emit/rust/stage3.rs | 2 +- .../src/protocols/jolt/emit/rust/stage4.rs | 2 +- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../src/protocols/jolt/emit/rust/stage6.rs | 2 +- .../src/protocols/jolt/emit/rust/stage7.rs | 2 +- .../jolt/verifier_common.rs.template | 2 +- crates/bolt/tests/verifier_cleanup.rs | 20 +++++++++++++++++++ crates/jolt-equivalence/src/plan_adapters.rs | 4 ++-- crates/jolt-verifier/src/stages/common.rs | 2 +- .../jolt-verifier/src/stages/stage1_outer.rs | 4 ++-- crates/jolt-verifier/src/stages/stage2.rs | 12 +++++------ crates/jolt-verifier/src/stages/stage3.rs | 6 +++--- crates/jolt-verifier/src/stages/stage4.rs | 4 ++-- crates/jolt-verifier/src/stages/stage5.rs | 6 +++--- crates/jolt-verifier/src/stages/stage6.rs | 12 +++++------ crates/jolt-verifier/src/stages/stage7.rs | 2 +- 18 files changed, 54 insertions(+), 34 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs index 3a8d18bdaa..841f0bf49e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs @@ -1171,7 +1171,7 @@ pub enum VerifyStage1Error { relation )?, rust_str(&claim.claim_value), - rust_str(&claim.input_openings.join("|")) + super::plan_tokens::rust_str_slice_expr(&claim.input_openings) )); } let claims = claims.join("\n"); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 91cd3a87bf..86fb8fe531 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -1308,7 +1308,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); relation )?, rust_str(&claim.claim_value), - rust_str(&claim.input_openings.join("|")) + super::plan_tokens::rust_str_slice_expr(&claim.input_openings) )); } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 21f23cfd10..26dd65f966 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1312,7 +1312,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); relation )?, rust_str(&claim.claim_value), - rust_str(&claim.input_openings.join("|")) + super::plan_tokens::rust_str_slice_expr(&claim.input_openings) )); } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 782fa01da9..06d247f6f3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -1496,7 +1496,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); claim.relation.as_deref() )?, rust_str(&claim.claim_value), - rust_str(&claim.input_openings.join("|")) + super::plan_tokens::rust_str_slice_expr(&claim.input_openings) )) }) .collect::, EmitError>>()? diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 44495d2da6..7d9498fefc 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1498,7 +1498,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); claim.relation.as_deref() )?, rust_str(&claim.claim_value), - rust_str(&claim.input_openings.join("|")) + super::plan_tokens::rust_str_slice_expr(&claim.input_openings) )) }) .collect::, EmitError>>()? diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 9e548d1149..fa69e99f25 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1638,7 +1638,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); claim.relation.as_deref() )?, rust_str(&claim.claim_value), - rust_str(&claim.input_openings.join("|")) + super::plan_tokens::rust_str_slice_expr(&claim.input_openings) )) }) .collect::, EmitError>>()? diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 35d6d77be6..2615610012 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1534,7 +1534,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); claim.relation.as_deref() )?, rust_str(&claim.claim_value), - rust_str(&claim.input_openings.join("|")) + super::plan_tokens::rust_str_slice_expr(&claim.input_openings) )) }) .collect::, EmitError>>()? diff --git a/crates/bolt/src/protocols/jolt/verifier_common.rs.template b/crates/bolt/src/protocols/jolt/verifier_common.rs.template index 0018ad477e..92f15bdb9c 100644 --- a/crates/bolt/src/protocols/jolt/verifier_common.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_common.rs.template @@ -177,7 +177,7 @@ pub struct SumcheckClaimPlan { pub kernel: Option<&'static str>, pub relation: Option, pub claim_value: &'static str, - pub input_openings: &'static str, + pub input_openings: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 2a09b3a379..ec84c3e8cf 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -19,6 +19,7 @@ const STAGE6_STAGE7_BASELINE_LOC_CEILING: usize = STAGE6_STAGE7_TARGET_LOC; const STAGE_LOCAL_PLAN_STRUCT_BASELINE_CEILING: usize = 18; const FIELD_EXPR_OPERAND_CONSTANT_BASELINE_CEILING: usize = 0; const BATCH_OPERAND_STRING_SITE_BASELINE_CEILING: usize = 0; +const CLAIM_INPUT_OPENING_STRING_SITE_BASELINE_CEILING: usize = 0; const STAGE_HELPER_FUNCTION_BASELINE_CEILING: usize = 38; const RELATION_STRING_SITE_BASELINE_CEILING: usize = 0; @@ -116,6 +117,7 @@ struct VerifierCleanupMetrics { stage_local_generic_plan_structs: usize, field_expr_operand_constants: usize, batch_operand_string_sites: usize, + claim_input_opening_string_sites: usize, stage_local_helper_functions: usize, relation_string_sites: usize, } @@ -138,6 +140,7 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { stage_local_generic_plan_structs: {plan_structs} (baseline ceiling <= {plan_baseline})\n\ field_expr_operand_constants: {operand_constants} (baseline ceiling <= {operand_baseline})\n\ batch_operand_string_sites: {batch_operand_string_sites} (baseline ceiling <= {batch_operand_baseline})\n\ + claim_input_opening_string_sites: {claim_input_opening_string_sites} (baseline ceiling <= {claim_input_opening_baseline})\n\ stage_local_helper_functions: {helper_functions} (baseline ceiling <= {helper_baseline})\n\ relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})", generated_surface_loc = metrics.generated_surface_loc, @@ -160,6 +163,8 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { operand_baseline = FIELD_EXPR_OPERAND_CONSTANT_BASELINE_CEILING, batch_operand_string_sites = metrics.batch_operand_string_sites, batch_operand_baseline = BATCH_OPERAND_STRING_SITE_BASELINE_CEILING, + claim_input_opening_string_sites = metrics.claim_input_opening_string_sites, + claim_input_opening_baseline = CLAIM_INPUT_OPENING_STRING_SITE_BASELINE_CEILING, helper_functions = metrics.stage_local_helper_functions, helper_baseline = STAGE_HELPER_FUNCTION_BASELINE_CEILING, relation_sites = metrics.relation_string_sites, @@ -210,6 +215,12 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { "batch operand string sites grew to {}; prefer structured claim slices", metrics.batch_operand_string_sites ); + assert!( + metrics.claim_input_opening_string_sites + == CLAIM_INPUT_OPENING_STRING_SITE_BASELINE_CEILING, + "claim input-opening string sites grew to {}; prefer structured input-opening slices", + metrics.claim_input_opening_string_sites + ); assert!( metrics.stage_local_helper_functions <= STAGE_HELPER_FUNCTION_BASELINE_CEILING, "stage-local helper function count grew to {}; factor verifier mechanics into shared runtime", @@ -438,6 +449,8 @@ fn verifier_cleanup_metrics(verifier_src: &Path) -> VerifierCleanupMetrics { count_stage_local_generic_plan_structs(&source); metrics.field_expr_operand_constants += count_field_expr_operand_constants(&source); metrics.batch_operand_string_sites += count_batch_operand_string_sites(&source); + metrics.claim_input_opening_string_sites += + count_claim_input_opening_string_sites(&source); metrics.stage_local_helper_functions += count_stage_local_helper_functions(&source); metrics.relation_string_sites += count_relation_string_sites(&source); } @@ -487,6 +500,13 @@ fn count_batch_operand_string_sites(source: &str) -> usize { .count() } +fn count_claim_input_opening_string_sites(source: &str) -> usize { + source + .lines() + .filter(|line| line.contains("input_openings: \"")) + .count() +} + fn count_stage_local_helper_functions(source: &str) -> usize { const HELPER_PREFIXES: &[&str] = &[ "fn evaluate_stage", diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 30029afe6e..f955705cdf 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -50,7 +50,7 @@ macro_rules! stage_claim { kernel: $plan.kernel.as_deref().map(super::leak_str), relation: $plan.relation.as_deref().map(super::leak_str), claim_value: super::leak_str(&$plan.claim_value), - input_openings: stage_list!(kernel, &$plan.input_openings), + input_openings: stage_batch_list!(kernel, &$plan.input_openings), } }; (generated, $module:ident, $claim:ident, $plan:ident) => { @@ -67,7 +67,7 @@ macro_rules! stage_claim { .as_deref() .map(|relation| generated_relation_kind!(relation)), claim_value: super::leak_str(&$plan.claim_value), - input_openings: stage_list!(generated, &$plan.input_openings), + input_openings: stage_batch_list!(generated, &$plan.input_openings), } }; } diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs index 0018ad477e..92f15bdb9c 100644 --- a/crates/jolt-verifier/src/stages/common.rs +++ b/crates/jolt-verifier/src/stages/common.rs @@ -177,7 +177,7 @@ pub struct SumcheckClaimPlan { pub kernel: Option<&'static str>, pub relation: Option, pub claim_value: &'static str, - pub input_openings: &'static str, + pub input_openings: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] diff --git a/crates/jolt-verifier/src/stages/stage1_outer.rs b/crates/jolt-verifier/src/stages/stage1_outer.rs index b05d6fc0f8..20b0e24ee3 100644 --- a/crates/jolt-verifier/src/stages/stage1_outer.rs +++ b/crates/jolt-verifier/src/stages/stage1_outer.rs @@ -44,8 +44,8 @@ pub const STAGE1_TRANSCRIPT_SQUEEZES: &[Stage1TranscriptSqueezePlan] = &[ ]; pub const STAGE1_SUMCHECK_CLAIMS: &[Stage1SumcheckClaimPlan] = &[ - Stage1SumcheckClaimPlan { symbol: "stage1.uniskip.input", stage: "stage1", domain: "jolt.stage1_uniskip_domain", num_rounds: 1, degree: 27, claim: "stage1.zero", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterUniskip), claim_value: "stage1.zero", input_openings: "" }, - Stage1SumcheckClaimPlan { symbol: "stage1.outer_remaining.input", stage: "stage1", domain: "jolt.trace_domain", num_rounds: 17, degree: 3, claim: "stage1.uniskip.eval", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterRemaining), claim_value: "stage1.uniskip.eval", input_openings: "stage1.uniskip.opening" }, + Stage1SumcheckClaimPlan { symbol: "stage1.uniskip.input", stage: "stage1", domain: "jolt.stage1_uniskip_domain", num_rounds: 1, degree: 27, claim: "stage1.zero", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterUniskip), claim_value: "stage1.zero", input_openings: &[] }, + Stage1SumcheckClaimPlan { symbol: "stage1.outer_remaining.input", stage: "stage1", domain: "jolt.trace_domain", num_rounds: 17, degree: 3, claim: "stage1.uniskip.eval", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterRemaining), claim_value: "stage1.uniskip.eval", input_openings: &["stage1.uniskip.opening"] }, ]; pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1]; diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index c3ea7fb0d6..f4616a30fe 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -135,12 +135,12 @@ pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.LeftInstructionInput", "stage2.instruction_lookup.term.RightInstructionInput"] }, ]; pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[ - Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr", input_openings: "stage2.input.stage1.Product|stage2.input.stage1.ShouldBranch|stage2.input.stage1.ShouldJump" }, - Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some(Stage2RelationKind::Stage2RamReadWrite), claim_value: "stage2.ram_read_write.claim_expr", input_openings: "stage2.input.stage1.RamReadValue|stage2.input.stage1.RamWriteValue" }, - Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.remainder.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage2.product_virtual.uniskip.opening", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualRemainder), claim_value: "stage2.product_virtual.uniskip.eval.UnivariateSkip", input_openings: "stage2.product_virtual.uniskip.opening.UnivariateSkip" }, - Stage2SumcheckClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage2.instruction_lookup.weighted_operands", kernel: None, relation: Some(Stage2RelationKind::Stage2InstructionLookupClaimReduction), claim_value: "stage2.instruction_lookup.claim_reduction.claim_expr", input_openings: "stage2.input.stage1.LookupOutput|stage2.input.stage1.LeftLookupOperand|stage2.input.stage1.RightLookupOperand|stage2.input.stage1.LeftInstructionInput|stage2.input.stage1.RightInstructionInput" }, - Stage2SumcheckClaimPlan { symbol: "stage2.ram_raf.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 2, claim: "stage2.ram_raf.ram_address", kernel: None, relation: Some(Stage2RelationKind::Stage2RamRafEvaluation), claim_value: "stage2.input.stage1.RamAddress", input_openings: "stage2.input.stage1.RamAddress" }, - Stage2SumcheckClaimPlan { symbol: "stage2.ram_output.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 3, claim: "zero", kernel: None, relation: Some(Stage2RelationKind::Stage2RamOutputCheck), claim_value: "stage2.ram_output.zero", input_openings: "" }, + Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr", input_openings: &["stage2.input.stage1.Product", "stage2.input.stage1.ShouldBranch", "stage2.input.stage1.ShouldJump"] }, + Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some(Stage2RelationKind::Stage2RamReadWrite), claim_value: "stage2.ram_read_write.claim_expr", input_openings: &["stage2.input.stage1.RamReadValue", "stage2.input.stage1.RamWriteValue"] }, + Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.remainder.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage2.product_virtual.uniskip.opening", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualRemainder), claim_value: "stage2.product_virtual.uniskip.eval.UnivariateSkip", input_openings: &["stage2.product_virtual.uniskip.opening.UnivariateSkip"] }, + Stage2SumcheckClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage2.instruction_lookup.weighted_operands", kernel: None, relation: Some(Stage2RelationKind::Stage2InstructionLookupClaimReduction), claim_value: "stage2.instruction_lookup.claim_reduction.claim_expr", input_openings: &["stage2.input.stage1.LookupOutput", "stage2.input.stage1.LeftLookupOperand", "stage2.input.stage1.RightLookupOperand", "stage2.input.stage1.LeftInstructionInput", "stage2.input.stage1.RightInstructionInput"] }, + Stage2SumcheckClaimPlan { symbol: "stage2.ram_raf.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 2, claim: "stage2.ram_raf.ram_address", kernel: None, relation: Some(Stage2RelationKind::Stage2RamRafEvaluation), claim_value: "stage2.input.stage1.RamAddress", input_openings: &["stage2.input.stage1.RamAddress"] }, + Stage2SumcheckClaimPlan { symbol: "stage2.ram_output.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 3, claim: "zero", kernel: None, relation: Some(Stage2RelationKind::Stage2RamOutputCheck), claim_value: "stage2.ram_output.zero", input_openings: &[] }, ]; pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1]; diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 322745e58c..822c8f0a15 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -105,9 +105,9 @@ pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[ Stage3FieldExprPlan { symbol: "stage3.registers.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers.partial.RdWriteValueRs1Value", "stage3.registers.term.Rs2Value"] }, ]; pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[ - Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr", input_openings: "stage3.input.stage1.NextUnexpandedPC|stage3.input.stage1.NextPC|stage3.input.stage1.NextIsVirtual|stage3.input.stage1.NextIsFirstInSequence|stage3.input.stage2.product_virtual.NextIsNoop" }, - Stage3SumcheckClaimPlan { symbol: "stage3.instruction_input.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage3.instruction_input.weighted_inputs", kernel: None, relation: Some(Stage3RelationKind::Stage3InstructionInput), claim_value: "stage3.instruction_input.claim_expr", input_openings: "stage3.input.stage2.product_virtual.RightInstructionInput|stage3.input.stage2.product_virtual.LeftInstructionInput" }, - Stage3SumcheckClaimPlan { symbol: "stage3.registers_claim_reduction.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.registers.weighted_register_values", kernel: None, relation: Some(Stage3RelationKind::Stage3RegistersClaimReduction), claim_value: "stage3.registers.claim_expr", input_openings: "stage3.input.stage1.RdWriteValue|stage3.input.stage1.Rs1Value|stage3.input.stage1.Rs2Value" }, + Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr", input_openings: &["stage3.input.stage1.NextUnexpandedPC", "stage3.input.stage1.NextPC", "stage3.input.stage1.NextIsVirtual", "stage3.input.stage1.NextIsFirstInSequence", "stage3.input.stage2.product_virtual.NextIsNoop"] }, + Stage3SumcheckClaimPlan { symbol: "stage3.instruction_input.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage3.instruction_input.weighted_inputs", kernel: None, relation: Some(Stage3RelationKind::Stage3InstructionInput), claim_value: "stage3.instruction_input.claim_expr", input_openings: &["stage3.input.stage2.product_virtual.RightInstructionInput", "stage3.input.stage2.product_virtual.LeftInstructionInput"] }, + Stage3SumcheckClaimPlan { symbol: "stage3.registers_claim_reduction.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.registers.weighted_register_values", kernel: None, relation: Some(Stage3RelationKind::Stage3RegistersClaimReduction), claim_value: "stage3.registers.claim_expr", input_openings: &["stage3.input.stage1.RdWriteValue", "stage3.input.stage1.Rs1Value", "stage3.input.stage1.Rs2Value"] }, ]; pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16]; diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index d1aca192d0..f659b18c39 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -100,8 +100,8 @@ pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[ ]; pub const STAGE4_SUMCHECK_CLAIMS: &[Stage4SumcheckClaimPlan] = &[ - Stage4SumcheckClaimPlan { symbol: "stage4.registers_read_write.input", stage: "stage4", domain: "jolt.stage4_registers_rw_domain", num_rounds: 23, degree: 3, claim: "stage4.registers_read_write.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RegistersReadWrite), claim_value: "stage4.registers_read_write.claim_expr", input_openings: "stage4.input.stage3.registers.RdWriteValue|stage4.input.stage3.registers.Rs1Value|stage4.input.stage3.registers.Rs2Value" }, - Stage4SumcheckClaimPlan { symbol: "stage4.ram_val_check.input", stage: "stage4", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage4.ram_val_check.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RamValCheck), claim_value: "stage4.ram_val_check.claim_expr", input_openings: "stage4.input.stage2.RamVal|stage4.input.stage2.RamValFinal|stage4.input.initial_ram.RamValInit" }, + Stage4SumcheckClaimPlan { symbol: "stage4.registers_read_write.input", stage: "stage4", domain: "jolt.stage4_registers_rw_domain", num_rounds: 23, degree: 3, claim: "stage4.registers_read_write.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RegistersReadWrite), claim_value: "stage4.registers_read_write.claim_expr", input_openings: &["stage4.input.stage3.registers.RdWriteValue", "stage4.input.stage3.registers.Rs1Value", "stage4.input.stage3.registers.Rs2Value"] }, + Stage4SumcheckClaimPlan { symbol: "stage4.ram_val_check.input", stage: "stage4", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage4.ram_val_check.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RamValCheck), claim_value: "stage4.ram_val_check.claim_expr", input_openings: &["stage4.input.stage2.RamVal", "stage4.input.stage2.RamValFinal", "stage4.input.initial_ram.RamValInit"] }, ]; pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16, 7]; diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index d097646940..d5478c4efe 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -101,9 +101,9 @@ pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[ ]; pub const STAGE5_SUMCHECK_CLAIMS: &[Stage5SumcheckClaimPlan] = &[ - Stage5SumcheckClaimPlan { symbol: "stage5.instruction_read_raf.input", stage: "stage5", domain: "jolt.stage5_instruction_read_raf_domain", num_rounds: 144, degree: 10, claim: "stage5.instruction_read_raf.weighted_lookup_values", kernel: None, relation: Some(Stage5RelationKind::Stage5InstructionReadRaf), claim_value: "stage5.instruction_read_raf.claim_expr", input_openings: "stage5.input.stage2.instruction.LookupOutput|stage5.input.stage2.instruction.LeftLookupOperand|stage5.input.stage2.instruction.RightLookupOperand" }, - Stage5SumcheckClaimPlan { symbol: "stage5.ram_ra_claim_reduction.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage5.ram_ra_claim_reduction.weighted_ram_ra", kernel: None, relation: Some(Stage5RelationKind::Stage5RamRaClaimReduction), claim_value: "stage5.ram_ra_claim_reduction.claim_expr", input_openings: "stage5.input.stage2.ram_raf.RamRa|stage5.input.stage2.ram_read_write.RamRa|stage5.input.stage4.ram_val_check.RamRa" }, - Stage5SumcheckClaimPlan { symbol: "stage5.registers_val_evaluation.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage5.registers_val_evaluation.registers_val", kernel: None, relation: Some(Stage5RelationKind::Stage5RegistersValEvaluation), claim_value: "stage5.input.stage4.registers.RegistersVal", input_openings: "stage5.input.stage4.registers.RegistersVal" }, + Stage5SumcheckClaimPlan { symbol: "stage5.instruction_read_raf.input", stage: "stage5", domain: "jolt.stage5_instruction_read_raf_domain", num_rounds: 144, degree: 10, claim: "stage5.instruction_read_raf.weighted_lookup_values", kernel: None, relation: Some(Stage5RelationKind::Stage5InstructionReadRaf), claim_value: "stage5.instruction_read_raf.claim_expr", input_openings: &["stage5.input.stage2.instruction.LookupOutput", "stage5.input.stage2.instruction.LeftLookupOperand", "stage5.input.stage2.instruction.RightLookupOperand"] }, + Stage5SumcheckClaimPlan { symbol: "stage5.ram_ra_claim_reduction.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage5.ram_ra_claim_reduction.weighted_ram_ra", kernel: None, relation: Some(Stage5RelationKind::Stage5RamRaClaimReduction), claim_value: "stage5.ram_ra_claim_reduction.claim_expr", input_openings: &["stage5.input.stage2.ram_raf.RamRa", "stage5.input.stage2.ram_read_write.RamRa", "stage5.input.stage4.ram_val_check.RamRa"] }, + Stage5SumcheckClaimPlan { symbol: "stage5.registers_val_evaluation.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage5.registers_val_evaluation.registers_val", kernel: None, relation: Some(Stage5RelationKind::Stage5RegistersValEvaluation), claim_value: "stage5.input.stage4.registers.RegistersVal", input_openings: &["stage5.input.stage4.registers.RegistersVal"] }, ]; pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[128, 16]; diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 5deb289bce..8ba5419f14 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -351,12 +351,12 @@ pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ ]; pub const STAGE6_SUMCHECK_CLAIMS: &[Stage6SumcheckClaimPlan] = &[ - Stage6SumcheckClaimPlan { symbol: "stage6.bytecode_read_raf.input", stage: "stage6", domain: "jolt.stage6_bytecode_read_raf_domain", num_rounds: 26, degree: 4, claim: "stage6.bytecode_read_raf.weighted_prior_stage_values", kernel: None, relation: Some(Stage6RelationKind::Stage6BytecodeReadRaf), claim_value: "stage6.bytecode_read_raf.claim_expr.partial76", input_openings: "stage6.input.stage1.UnexpandedPC|stage6.input.stage1.Imm|stage6.input.stage1.OpFlagAddOperands|stage6.input.stage1.OpFlagSubtractOperands|stage6.input.stage1.OpFlagMultiplyOperands|stage6.input.stage1.OpFlagLoad|stage6.input.stage1.OpFlagStore|stage6.input.stage1.OpFlagJump|stage6.input.stage1.OpFlagWriteLookupOutputToRD|stage6.input.stage1.OpFlagVirtualInstruction|stage6.input.stage1.OpFlagAssert|stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC|stage6.input.stage1.OpFlagAdvice|stage6.input.stage1.OpFlagIsCompressed|stage6.input.stage1.OpFlagIsFirstInSequence|stage6.input.stage1.OpFlagIsLastInSequence|stage6.input.stage2.OpFlagJump|stage6.input.stage2.InstructionFlagBranch|stage6.input.stage2.OpFlagWriteLookupOutputToRD|stage6.input.stage2.OpFlagVirtualInstruction|stage6.input.stage3.instruction_input.Imm|stage6.input.stage3.spartan_shift.UnexpandedPC|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value|stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value|stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm|stage6.input.stage3.spartan_shift.InstructionFlagIsNoop|stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction|stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence|stage6.input.stage4.RdWa|stage6.input.stage4.Rs1Ra|stage6.input.stage4.Rs2Ra|stage6.input.stage5.registers_val_evaluation.RdWa|stage6.input.stage5.InstructionRafFlag|stage6.input.stage5.LookupTableFlag_0|stage6.input.stage5.LookupTableFlag_1|stage6.input.stage5.LookupTableFlag_2|stage6.input.stage5.LookupTableFlag_3|stage6.input.stage5.LookupTableFlag_4|stage6.input.stage5.LookupTableFlag_5|stage6.input.stage5.LookupTableFlag_6|stage6.input.stage5.LookupTableFlag_7|stage6.input.stage5.LookupTableFlag_8|stage6.input.stage5.LookupTableFlag_9|stage6.input.stage5.LookupTableFlag_10|stage6.input.stage5.LookupTableFlag_11|stage6.input.stage5.LookupTableFlag_12|stage6.input.stage5.LookupTableFlag_13|stage6.input.stage5.LookupTableFlag_14|stage6.input.stage5.LookupTableFlag_15|stage6.input.stage5.LookupTableFlag_16|stage6.input.stage5.LookupTableFlag_17|stage6.input.stage5.LookupTableFlag_18|stage6.input.stage5.LookupTableFlag_19|stage6.input.stage5.LookupTableFlag_20|stage6.input.stage5.LookupTableFlag_21|stage6.input.stage5.LookupTableFlag_22|stage6.input.stage5.LookupTableFlag_23|stage6.input.stage5.LookupTableFlag_24|stage6.input.stage5.LookupTableFlag_25|stage6.input.stage5.LookupTableFlag_26|stage6.input.stage5.LookupTableFlag_27|stage6.input.stage5.LookupTableFlag_28|stage6.input.stage5.LookupTableFlag_29|stage6.input.stage5.LookupTableFlag_30|stage6.input.stage5.LookupTableFlag_31|stage6.input.stage5.LookupTableFlag_32|stage6.input.stage5.LookupTableFlag_33|stage6.input.stage5.LookupTableFlag_34|stage6.input.stage5.LookupTableFlag_35|stage6.input.stage5.LookupTableFlag_36|stage6.input.stage5.LookupTableFlag_37|stage6.input.stage5.LookupTableFlag_38|stage6.input.stage5.LookupTableFlag_39|stage6.input.stage5.LookupTableFlag_40|stage6.input.stage1.PC|stage6.input.stage3.spartan_shift.PC" }, - Stage6SumcheckClaimPlan { symbol: "stage6.booleanity.input", stage: "stage6", domain: "jolt.stage6_booleanity_domain", num_rounds: 20, degree: 3, claim: "stage6.booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6Booleanity), claim_value: "stage6.zero", input_openings: "" }, - Stage6SumcheckClaimPlan { symbol: "stage6.hamming_booleanity.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage6.hamming_booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6HammingBooleanity), claim_value: "stage6.zero", input_openings: "stage6.input.stage1.LookupOutput" }, - Stage6SumcheckClaimPlan { symbol: "stage6.ram_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.ram_ra_virtual.weighted_ram_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6RamRaVirtual), claim_value: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", input_openings: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" }, - Stage6SumcheckClaimPlan { symbol: "stage6.instruction_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.instruction_ra_virtual.weighted_instruction_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6InstructionRaVirtual), claim_value: "stage6.instruction_ra_virtual.claim_expr.partial6", input_openings: "stage6.input.stage5.instruction_read_raf.InstructionRa_0|stage6.input.stage5.instruction_read_raf.InstructionRa_1|stage6.input.stage5.instruction_read_raf.InstructionRa_2|stage6.input.stage5.instruction_read_raf.InstructionRa_3|stage6.input.stage5.instruction_read_raf.InstructionRa_4|stage6.input.stage5.instruction_read_raf.InstructionRa_5|stage6.input.stage5.instruction_read_raf.InstructionRa_6|stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, - Stage6SumcheckClaimPlan { symbol: "stage6.inc_claim_reduction.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage6.inc_claim_reduction.weighted_increments", kernel: None, relation: Some(Stage6RelationKind::Stage6IncClaimReduction), claim_value: "stage6.inc_claim_reduction.claim_expr.partial2", input_openings: "stage6.input.stage2.ram_read_write.RamInc|stage6.input.stage4.ram_val_check.RamInc|stage6.input.stage4.registers_read_write.RdInc|stage6.input.stage5.registers_val_evaluation.RdInc" }, + Stage6SumcheckClaimPlan { symbol: "stage6.bytecode_read_raf.input", stage: "stage6", domain: "jolt.stage6_bytecode_read_raf_domain", num_rounds: 26, degree: 4, claim: "stage6.bytecode_read_raf.weighted_prior_stage_values", kernel: None, relation: Some(Stage6RelationKind::Stage6BytecodeReadRaf), claim_value: "stage6.bytecode_read_raf.claim_expr.partial76", input_openings: &["stage6.input.stage1.UnexpandedPC", "stage6.input.stage1.Imm", "stage6.input.stage1.OpFlagAddOperands", "stage6.input.stage1.OpFlagSubtractOperands", "stage6.input.stage1.OpFlagMultiplyOperands", "stage6.input.stage1.OpFlagLoad", "stage6.input.stage1.OpFlagStore", "stage6.input.stage1.OpFlagJump", "stage6.input.stage1.OpFlagWriteLookupOutputToRD", "stage6.input.stage1.OpFlagVirtualInstruction", "stage6.input.stage1.OpFlagAssert", "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC", "stage6.input.stage1.OpFlagAdvice", "stage6.input.stage1.OpFlagIsCompressed", "stage6.input.stage1.OpFlagIsFirstInSequence", "stage6.input.stage1.OpFlagIsLastInSequence", "stage6.input.stage2.OpFlagJump", "stage6.input.stage2.InstructionFlagBranch", "stage6.input.stage2.OpFlagWriteLookupOutputToRD", "stage6.input.stage2.OpFlagVirtualInstruction", "stage6.input.stage3.instruction_input.Imm", "stage6.input.stage3.spartan_shift.UnexpandedPC", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm", "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop", "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction", "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence", "stage6.input.stage4.RdWa", "stage6.input.stage4.Rs1Ra", "stage6.input.stage4.Rs2Ra", "stage6.input.stage5.registers_val_evaluation.RdWa", "stage6.input.stage5.InstructionRafFlag", "stage6.input.stage5.LookupTableFlag_0", "stage6.input.stage5.LookupTableFlag_1", "stage6.input.stage5.LookupTableFlag_2", "stage6.input.stage5.LookupTableFlag_3", "stage6.input.stage5.LookupTableFlag_4", "stage6.input.stage5.LookupTableFlag_5", "stage6.input.stage5.LookupTableFlag_6", "stage6.input.stage5.LookupTableFlag_7", "stage6.input.stage5.LookupTableFlag_8", "stage6.input.stage5.LookupTableFlag_9", "stage6.input.stage5.LookupTableFlag_10", "stage6.input.stage5.LookupTableFlag_11", "stage6.input.stage5.LookupTableFlag_12", "stage6.input.stage5.LookupTableFlag_13", "stage6.input.stage5.LookupTableFlag_14", "stage6.input.stage5.LookupTableFlag_15", "stage6.input.stage5.LookupTableFlag_16", "stage6.input.stage5.LookupTableFlag_17", "stage6.input.stage5.LookupTableFlag_18", "stage6.input.stage5.LookupTableFlag_19", "stage6.input.stage5.LookupTableFlag_20", "stage6.input.stage5.LookupTableFlag_21", "stage6.input.stage5.LookupTableFlag_22", "stage6.input.stage5.LookupTableFlag_23", "stage6.input.stage5.LookupTableFlag_24", "stage6.input.stage5.LookupTableFlag_25", "stage6.input.stage5.LookupTableFlag_26", "stage6.input.stage5.LookupTableFlag_27", "stage6.input.stage5.LookupTableFlag_28", "stage6.input.stage5.LookupTableFlag_29", "stage6.input.stage5.LookupTableFlag_30", "stage6.input.stage5.LookupTableFlag_31", "stage6.input.stage5.LookupTableFlag_32", "stage6.input.stage5.LookupTableFlag_33", "stage6.input.stage5.LookupTableFlag_34", "stage6.input.stage5.LookupTableFlag_35", "stage6.input.stage5.LookupTableFlag_36", "stage6.input.stage5.LookupTableFlag_37", "stage6.input.stage5.LookupTableFlag_38", "stage6.input.stage5.LookupTableFlag_39", "stage6.input.stage5.LookupTableFlag_40", "stage6.input.stage1.PC", "stage6.input.stage3.spartan_shift.PC"] }, + Stage6SumcheckClaimPlan { symbol: "stage6.booleanity.input", stage: "stage6", domain: "jolt.stage6_booleanity_domain", num_rounds: 20, degree: 3, claim: "stage6.booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6Booleanity), claim_value: "stage6.zero", input_openings: &[] }, + Stage6SumcheckClaimPlan { symbol: "stage6.hamming_booleanity.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage6.hamming_booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6HammingBooleanity), claim_value: "stage6.zero", input_openings: &["stage6.input.stage1.LookupOutput"] }, + Stage6SumcheckClaimPlan { symbol: "stage6.ram_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.ram_ra_virtual.weighted_ram_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6RamRaVirtual), claim_value: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", input_openings: &["stage6.input.stage5.ram_ra_claim_reduction.RamRa"] }, + Stage6SumcheckClaimPlan { symbol: "stage6.instruction_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.instruction_ra_virtual.weighted_instruction_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6InstructionRaVirtual), claim_value: "stage6.instruction_ra_virtual.claim_expr.partial6", input_openings: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.input.stage5.instruction_read_raf.InstructionRa_1", "stage6.input.stage5.instruction_read_raf.InstructionRa_2", "stage6.input.stage5.instruction_read_raf.InstructionRa_3", "stage6.input.stage5.instruction_read_raf.InstructionRa_4", "stage6.input.stage5.instruction_read_raf.InstructionRa_5", "stage6.input.stage5.instruction_read_raf.InstructionRa_6", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"] }, + Stage6SumcheckClaimPlan { symbol: "stage6.inc_claim_reduction.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage6.inc_claim_reduction.weighted_increments", kernel: None, relation: Some(Stage6RelationKind::Stage6IncClaimReduction), claim_value: "stage6.inc_claim_reduction.claim_expr.partial2", input_openings: &["stage6.input.stage2.ram_read_write.RamInc", "stage6.input.stage4.ram_val_check.RamInc", "stage6.input.stage4.registers_read_write.RdInc", "stage6.input.stage5.registers_val_evaluation.RdInc"] }, ]; pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[10, 16]; diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 6a26103e9d..39f8954edc 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -210,7 +210,7 @@ pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ ]; pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[ - Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some(Stage7RelationKind::Stage7HammingWeightClaimReduction), claim_value: "stage7.hamming_weight_claim_reduction.claim_expr.partial115", input_openings: "stage7.input.stage6.hamming_booleanity.HammingWeight|stage7.input.stage6.booleanity.InstructionRa_0|stage7.input.stage6.instruction_ra_virtual.InstructionRa_0|stage7.input.stage6.booleanity.InstructionRa_1|stage7.input.stage6.instruction_ra_virtual.InstructionRa_1|stage7.input.stage6.booleanity.InstructionRa_2|stage7.input.stage6.instruction_ra_virtual.InstructionRa_2|stage7.input.stage6.booleanity.InstructionRa_3|stage7.input.stage6.instruction_ra_virtual.InstructionRa_3|stage7.input.stage6.booleanity.InstructionRa_4|stage7.input.stage6.instruction_ra_virtual.InstructionRa_4|stage7.input.stage6.booleanity.InstructionRa_5|stage7.input.stage6.instruction_ra_virtual.InstructionRa_5|stage7.input.stage6.booleanity.InstructionRa_6|stage7.input.stage6.instruction_ra_virtual.InstructionRa_6|stage7.input.stage6.booleanity.InstructionRa_7|stage7.input.stage6.instruction_ra_virtual.InstructionRa_7|stage7.input.stage6.booleanity.InstructionRa_8|stage7.input.stage6.instruction_ra_virtual.InstructionRa_8|stage7.input.stage6.booleanity.InstructionRa_9|stage7.input.stage6.instruction_ra_virtual.InstructionRa_9|stage7.input.stage6.booleanity.InstructionRa_10|stage7.input.stage6.instruction_ra_virtual.InstructionRa_10|stage7.input.stage6.booleanity.InstructionRa_11|stage7.input.stage6.instruction_ra_virtual.InstructionRa_11|stage7.input.stage6.booleanity.InstructionRa_12|stage7.input.stage6.instruction_ra_virtual.InstructionRa_12|stage7.input.stage6.booleanity.InstructionRa_13|stage7.input.stage6.instruction_ra_virtual.InstructionRa_13|stage7.input.stage6.booleanity.InstructionRa_14|stage7.input.stage6.instruction_ra_virtual.InstructionRa_14|stage7.input.stage6.booleanity.InstructionRa_15|stage7.input.stage6.instruction_ra_virtual.InstructionRa_15|stage7.input.stage6.booleanity.InstructionRa_16|stage7.input.stage6.instruction_ra_virtual.InstructionRa_16|stage7.input.stage6.booleanity.InstructionRa_17|stage7.input.stage6.instruction_ra_virtual.InstructionRa_17|stage7.input.stage6.booleanity.InstructionRa_18|stage7.input.stage6.instruction_ra_virtual.InstructionRa_18|stage7.input.stage6.booleanity.InstructionRa_19|stage7.input.stage6.instruction_ra_virtual.InstructionRa_19|stage7.input.stage6.booleanity.InstructionRa_20|stage7.input.stage6.instruction_ra_virtual.InstructionRa_20|stage7.input.stage6.booleanity.InstructionRa_21|stage7.input.stage6.instruction_ra_virtual.InstructionRa_21|stage7.input.stage6.booleanity.InstructionRa_22|stage7.input.stage6.instruction_ra_virtual.InstructionRa_22|stage7.input.stage6.booleanity.InstructionRa_23|stage7.input.stage6.instruction_ra_virtual.InstructionRa_23|stage7.input.stage6.booleanity.InstructionRa_24|stage7.input.stage6.instruction_ra_virtual.InstructionRa_24|stage7.input.stage6.booleanity.InstructionRa_25|stage7.input.stage6.instruction_ra_virtual.InstructionRa_25|stage7.input.stage6.booleanity.InstructionRa_26|stage7.input.stage6.instruction_ra_virtual.InstructionRa_26|stage7.input.stage6.booleanity.InstructionRa_27|stage7.input.stage6.instruction_ra_virtual.InstructionRa_27|stage7.input.stage6.booleanity.InstructionRa_28|stage7.input.stage6.instruction_ra_virtual.InstructionRa_28|stage7.input.stage6.booleanity.InstructionRa_29|stage7.input.stage6.instruction_ra_virtual.InstructionRa_29|stage7.input.stage6.booleanity.InstructionRa_30|stage7.input.stage6.instruction_ra_virtual.InstructionRa_30|stage7.input.stage6.booleanity.InstructionRa_31|stage7.input.stage6.instruction_ra_virtual.InstructionRa_31|stage7.input.stage6.booleanity.BytecodeRa_0|stage7.input.stage6.bytecode_read_raf.BytecodeRa_0|stage7.input.stage6.booleanity.BytecodeRa_1|stage7.input.stage6.bytecode_read_raf.BytecodeRa_1|stage7.input.stage6.booleanity.BytecodeRa_2|stage7.input.stage6.bytecode_read_raf.BytecodeRa_2|stage7.input.stage6.booleanity.RamRa_0|stage7.input.stage6.ram_ra_virtual.RamRa_0|stage7.input.stage6.booleanity.RamRa_1|stage7.input.stage6.ram_ra_virtual.RamRa_1|stage7.input.stage6.booleanity.RamRa_2|stage7.input.stage6.ram_ra_virtual.RamRa_2|stage7.input.stage6.booleanity.RamRa_3|stage7.input.stage6.ram_ra_virtual.RamRa_3" }, + Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some(Stage7RelationKind::Stage7HammingWeightClaimReduction), claim_value: "stage7.hamming_weight_claim_reduction.claim_expr.partial115", input_openings: &["stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.booleanity.InstructionRa_0", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", "stage7.input.stage6.booleanity.InstructionRa_1", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", "stage7.input.stage6.booleanity.InstructionRa_2", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", "stage7.input.stage6.booleanity.InstructionRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", "stage7.input.stage6.booleanity.InstructionRa_4", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", "stage7.input.stage6.booleanity.InstructionRa_5", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", "stage7.input.stage6.booleanity.InstructionRa_6", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", "stage7.input.stage6.booleanity.InstructionRa_7", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", "stage7.input.stage6.booleanity.InstructionRa_8", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", "stage7.input.stage6.booleanity.InstructionRa_9", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", "stage7.input.stage6.booleanity.InstructionRa_10", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", "stage7.input.stage6.booleanity.InstructionRa_11", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", "stage7.input.stage6.booleanity.InstructionRa_12", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", "stage7.input.stage6.booleanity.InstructionRa_13", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", "stage7.input.stage6.booleanity.InstructionRa_14", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", "stage7.input.stage6.booleanity.InstructionRa_15", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", "stage7.input.stage6.booleanity.InstructionRa_16", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", "stage7.input.stage6.booleanity.InstructionRa_17", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", "stage7.input.stage6.booleanity.InstructionRa_18", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", "stage7.input.stage6.booleanity.InstructionRa_19", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", "stage7.input.stage6.booleanity.InstructionRa_20", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", "stage7.input.stage6.booleanity.InstructionRa_21", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", "stage7.input.stage6.booleanity.InstructionRa_22", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", "stage7.input.stage6.booleanity.InstructionRa_23", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", "stage7.input.stage6.booleanity.InstructionRa_24", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", "stage7.input.stage6.booleanity.InstructionRa_25", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", "stage7.input.stage6.booleanity.InstructionRa_26", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", "stage7.input.stage6.booleanity.InstructionRa_27", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", "stage7.input.stage6.booleanity.InstructionRa_28", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", "stage7.input.stage6.booleanity.InstructionRa_29", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", "stage7.input.stage6.booleanity.InstructionRa_30", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", "stage7.input.stage6.booleanity.InstructionRa_31", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", "stage7.input.stage6.booleanity.BytecodeRa_0", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", "stage7.input.stage6.booleanity.BytecodeRa_1", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", "stage7.input.stage6.booleanity.BytecodeRa_2", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", "stage7.input.stage6.booleanity.RamRa_0", "stage7.input.stage6.ram_ra_virtual.RamRa_0", "stage7.input.stage6.booleanity.RamRa_1", "stage7.input.stage6.ram_ra_virtual.RamRa_1", "stage7.input.stage6.booleanity.RamRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_2", "stage7.input.stage6.booleanity.RamRa_3", "stage7.input.stage6.ram_ra_virtual.RamRa_3"] }, ]; pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[4]; From 2992666ad1fcee3b03b75a430760b563795c54cd Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 19:07:41 -0600 Subject: [PATCH 008/171] refactor(bolt): structure verifier point inputs --- .../src/protocols/jolt/emit/rust/stage2.rs | 2 +- .../src/protocols/jolt/emit/rust/stage3.rs | 2 +- .../src/protocols/jolt/emit/rust/stage4.rs | 2 +- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../src/protocols/jolt/emit/rust/stage6.rs | 2 +- .../src/protocols/jolt/emit/rust/stage7.rs | 2 +- .../jolt/verifier_common.rs.template | 8 +- crates/bolt/tests/verifier_cleanup.rs | 19 +++++ crates/jolt-equivalence/src/plan_adapters.rs | 15 +--- crates/jolt-verifier/src/stages/common.rs | 8 +- crates/jolt-verifier/src/stages/stage2.rs | 2 +- crates/jolt-verifier/src/stages/stage4.rs | 2 +- crates/jolt-verifier/src/stages/stage5.rs | 20 ++--- crates/jolt-verifier/src/stages/stage6.rs | 80 +++++++++---------- crates/jolt-verifier/src/stages/stage7.rs | 2 +- 15 files changed, 83 insertions(+), 85 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 86fb8fe531..f490ea2d79 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -1561,7 +1561,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); rust_str(&concat.symbol), rust_str(&concat.layout), concat.arity, - rust_str(&concat.inputs.join("|")) + super::plan_tokens::rust_str_slice_expr(&concat.inputs) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 26dd65f966..9180f5ccce 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1566,7 +1566,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); rust_str(&concat.symbol), rust_str(&concat.layout), concat.arity, - rust_str(&concat.inputs.join("|")) + super::plan_tokens::rust_str_slice_expr(&concat.inputs) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 06d247f6f3..f690b8721e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -1760,7 +1760,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); rust_str(&concat.symbol), rust_str(&concat.layout), concat.arity, - rust_str(&concat.inputs.join("|")) + super::plan_tokens::rust_str_slice_expr(&concat.inputs) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 7d9498fefc..f4aefa2134 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1762,7 +1762,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); rust_str(&concat.symbol), rust_str(&concat.layout), concat.arity, - rust_str(&concat.inputs.join("|")) + super::plan_tokens::rust_str_slice_expr(&concat.inputs) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index fa69e99f25..f001794bea 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1929,7 +1929,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); rust_str(&concat.symbol), rust_str(&concat.layout), concat.arity, - rust_str(&concat.inputs.join("|")) + super::plan_tokens::rust_str_slice_expr(&concat.inputs) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 2615610012..0266cf7e57 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1825,7 +1825,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); rust_str(&concat.symbol), rust_str(&concat.layout), concat.arity, - rust_str(&concat.inputs.join("|")) + super::plan_tokens::rust_str_slice_expr(&concat.inputs) ) }) .collect::>() diff --git a/crates/bolt/src/protocols/jolt/verifier_common.rs.template b/crates/bolt/src/protocols/jolt/verifier_common.rs.template index 92f15bdb9c..921096bd1e 100644 --- a/crates/bolt/src/protocols/jolt/verifier_common.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_common.rs.template @@ -254,7 +254,7 @@ pub struct PointConcatPlan { pub symbol: &'static str, pub layout: &'static str, pub arity: usize, - pub inputs: &'static str, + pub inputs: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -840,17 +840,13 @@ impl ValueStore { fn try_concat_point(&self, concat: &PointConcatPlan) -> Option> { let mut point = Vec::with_capacity(concat.arity); - for input in symbol_list(concat.inputs) { + for input in concat.inputs { point.extend_from_slice(self.try_point(input)?); } Some(point) } } -pub fn symbol_list(symbols: &'static str) -> impl Iterator { - symbols.split('|').filter(|symbol| !symbol.is_empty()) -} - pub fn find_plan<'a, T: SymbolPlan>(plans: &'a [T], symbol: &str) -> Option<&'a T> { plans.iter().find(|plan| plan.symbol() == symbol) } diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index ec84c3e8cf..16a953f491 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -20,6 +20,7 @@ const STAGE_LOCAL_PLAN_STRUCT_BASELINE_CEILING: usize = 18; const FIELD_EXPR_OPERAND_CONSTANT_BASELINE_CEILING: usize = 0; const BATCH_OPERAND_STRING_SITE_BASELINE_CEILING: usize = 0; const CLAIM_INPUT_OPENING_STRING_SITE_BASELINE_CEILING: usize = 0; +const POINT_CONCAT_INPUT_STRING_SITE_BASELINE_CEILING: usize = 0; const STAGE_HELPER_FUNCTION_BASELINE_CEILING: usize = 38; const RELATION_STRING_SITE_BASELINE_CEILING: usize = 0; @@ -118,6 +119,7 @@ struct VerifierCleanupMetrics { field_expr_operand_constants: usize, batch_operand_string_sites: usize, claim_input_opening_string_sites: usize, + point_concat_input_string_sites: usize, stage_local_helper_functions: usize, relation_string_sites: usize, } @@ -141,6 +143,7 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { field_expr_operand_constants: {operand_constants} (baseline ceiling <= {operand_baseline})\n\ batch_operand_string_sites: {batch_operand_string_sites} (baseline ceiling <= {batch_operand_baseline})\n\ claim_input_opening_string_sites: {claim_input_opening_string_sites} (baseline ceiling <= {claim_input_opening_baseline})\n\ + point_concat_input_string_sites: {point_concat_input_string_sites} (baseline ceiling <= {point_concat_input_baseline})\n\ stage_local_helper_functions: {helper_functions} (baseline ceiling <= {helper_baseline})\n\ relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})", generated_surface_loc = metrics.generated_surface_loc, @@ -165,6 +168,8 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { batch_operand_baseline = BATCH_OPERAND_STRING_SITE_BASELINE_CEILING, claim_input_opening_string_sites = metrics.claim_input_opening_string_sites, claim_input_opening_baseline = CLAIM_INPUT_OPENING_STRING_SITE_BASELINE_CEILING, + point_concat_input_string_sites = metrics.point_concat_input_string_sites, + point_concat_input_baseline = POINT_CONCAT_INPUT_STRING_SITE_BASELINE_CEILING, helper_functions = metrics.stage_local_helper_functions, helper_baseline = STAGE_HELPER_FUNCTION_BASELINE_CEILING, relation_sites = metrics.relation_string_sites, @@ -221,6 +226,11 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { "claim input-opening string sites grew to {}; prefer structured input-opening slices", metrics.claim_input_opening_string_sites ); + assert!( + metrics.point_concat_input_string_sites == POINT_CONCAT_INPUT_STRING_SITE_BASELINE_CEILING, + "point-concat input string sites grew to {}; prefer structured point input slices", + metrics.point_concat_input_string_sites + ); assert!( metrics.stage_local_helper_functions <= STAGE_HELPER_FUNCTION_BASELINE_CEILING, "stage-local helper function count grew to {}; factor verifier mechanics into shared runtime", @@ -451,6 +461,8 @@ fn verifier_cleanup_metrics(verifier_src: &Path) -> VerifierCleanupMetrics { metrics.batch_operand_string_sites += count_batch_operand_string_sites(&source); metrics.claim_input_opening_string_sites += count_claim_input_opening_string_sites(&source); + metrics.point_concat_input_string_sites += + count_point_concat_input_string_sites(&source); metrics.stage_local_helper_functions += count_stage_local_helper_functions(&source); metrics.relation_string_sites += count_relation_string_sites(&source); } @@ -507,6 +519,13 @@ fn count_claim_input_opening_string_sites(source: &str) -> usize { .count() } +fn count_point_concat_input_string_sites(source: &str) -> usize { + source + .lines() + .filter(|line| line.contains("PointConcatPlan") && line.contains("inputs: \"")) + .count() +} + fn count_stage_local_helper_functions(source: &str) -> usize { const HELPER_PREFIXES: &[&str] = &[ "fn evaluate_stage", diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index f955705cdf..18e88144df 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -4,15 +4,6 @@ //! Bolt's owned compiler plans into the currently generated static plan shape //! expected by jolt-kernels, jolt-prover, and jolt-verifier. -macro_rules! stage_list { - (kernel, $values:expr) => { - super::leak_str_slice($values) - }; - (generated, $values:expr) => { - super::leak_symbol_list($values) - }; -} - macro_rules! stage_batch_list { ($mode:ident, $values:expr) => { super::leak_str_slice($values) @@ -543,7 +534,7 @@ macro_rules! define_stage_adapter_impl { symbol: super::leak_str(&plan.symbol), layout: super::leak_str(&plan.layout), arity: plan.arity, - inputs: stage_list!($mode, &plan.inputs), + inputs: super::leak_str_slice(&plan.inputs), }) .collect(), ), @@ -1042,10 +1033,6 @@ fn leak_str_slice(values: &[String]) -> &'static [&'static str] { Box::leak(leaked.into_boxed_slice()) } -fn leak_symbol_list(values: &[String]) -> &'static str { - leak_str(&values.join("|")) -} - fn leak_usize_slice(values: &[usize]) -> &'static [usize] { Box::leak(values.to_vec().into_boxed_slice()) } diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs index 92f15bdb9c..921096bd1e 100644 --- a/crates/jolt-verifier/src/stages/common.rs +++ b/crates/jolt-verifier/src/stages/common.rs @@ -254,7 +254,7 @@ pub struct PointConcatPlan { pub symbol: &'static str, pub layout: &'static str, pub arity: usize, - pub inputs: &'static str, + pub inputs: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -840,17 +840,13 @@ impl ValueStore { fn try_concat_point(&self, concat: &PointConcatPlan) -> Option> { let mut point = Vec::with_capacity(concat.arity); - for input in symbol_list(concat.inputs) { + for input in concat.inputs { point.extend_from_slice(self.try_point(input)?); } Some(point) } } -pub fn symbol_list(symbols: &'static str) -> impl Iterator { - symbols.split('|').filter(|symbol| !symbol.is_empty()) -} - pub fn find_plan<'a, T: SymbolPlan>(plans: &'a [T], symbol: &str) -> Option<&'a T> { plans.iter().find(|plan| plan.symbol() == symbol) } diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index f4616a30fe..ca4eedd7c9 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -194,7 +194,7 @@ pub const STAGE2_POINT_SLICES: &[Stage2PointSlicePlan] = &[ ]; pub const STAGE2_POINT_CONCATS: &[Stage2PointConcatPlan] = &[ - Stage2PointConcatPlan { symbol: "stage2.ram_raf.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: "stage2.ram_raf.instance|stage2.input.stage1.RamAddress" }, + Stage2PointConcatPlan { symbol: "stage2.ram_raf.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: &["stage2.ram_raf.instance", "stage2.input.stage1.RamAddress"] }, ]; pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[ Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.uniskip.opening.UnivariateSkip", oracle: "UnivariateSkip", domain: "jolt.stage2_uniskip_domain", point_arity: 1, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.uniskip.instance", eval_source: "stage2.product_virtual.uniskip.eval.UnivariateSkip" }, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index f659b18c39..2bf9f37b0f 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -134,7 +134,7 @@ pub const STAGE4_POINT_SLICES: &[Stage4PointSlicePlan] = &[ ]; pub const STAGE4_POINT_CONCATS: &[Stage4PointConcatPlan] = &[ - Stage4PointConcatPlan { symbol: "stage4.ram_val_check.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: "stage4.ram_val_check.point.RamAddress|stage4.ram_val_check.instance" }, + Stage4PointConcatPlan { symbol: "stage4.ram_val_check.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: &["stage4.ram_val_check.point.RamAddress", "stage4.ram_val_check.instance"] }, ]; pub const STAGE4_OPENING_CLAIMS: &[Stage4OpeningClaimPlan] = &[ Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RegistersVal", oracle: "RegistersVal", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.RegistersVal" }, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index d5478c4efe..7813d89931 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -192,16 +192,16 @@ pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[ ]; pub const STAGE5_POINT_CONCATS: &[Stage5PointConcatPlan] = &[ - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_0.address|stage5.instruction_read_raf.point.Cycle" }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_1", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_1.address|stage5.instruction_read_raf.point.Cycle" }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_2", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_2.address|stage5.instruction_read_raf.point.Cycle" }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_3", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_3.address|stage5.instruction_read_raf.point.Cycle" }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_4", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_4.address|stage5.instruction_read_raf.point.Cycle" }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_5", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_5.address|stage5.instruction_read_raf.point.Cycle" }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_6", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_6.address|stage5.instruction_read_raf.point.Cycle" }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_7", layout: "address_chunk_then_cycle", arity: 32, inputs: "stage5.instruction_read_raf.point.InstructionRa_7.address|stage5.instruction_read_raf.point.Cycle" }, - Stage5PointConcatPlan { symbol: "stage5.ram_ra_claim_reduction.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: "stage5.ram_ra_claim_reduction.point.RamAddress|stage5.ram_ra_claim_reduction.instance" }, - Stage5PointConcatPlan { symbol: "stage5.registers_val_evaluation.point.RdWa", layout: "register_address_then_cycle", arity: 23, inputs: "stage5.registers_val_evaluation.point.RegisterAddress|stage5.registers_val_evaluation.instance" }, + Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_0.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_1", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_1.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_2", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_2.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_3", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_3.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_4", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_4.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_5", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_5.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_6", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_6.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_7", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_7.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointConcatPlan { symbol: "stage5.ram_ra_claim_reduction.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: &["stage5.ram_ra_claim_reduction.point.RamAddress", "stage5.ram_ra_claim_reduction.instance"] }, + Stage5PointConcatPlan { symbol: "stage5.registers_val_evaluation.point.RdWa", layout: "register_address_then_cycle", arity: 23, inputs: &["stage5.registers_val_evaluation.point.RegisterAddress", "stage5.registers_val_evaluation.instance"] }, ]; pub const STAGE5_OPENING_CLAIMS: &[Stage5OpeningClaimPlan] = &[ Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_0", oracle: "LookupTableFlag_0", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_0" }, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 8ba5419f14..b352d0a995 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -456,46 +456,46 @@ pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[ ]; pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[ - Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address", layout: "left_zero_padded_address_chunk", arity: 4, inputs: "stage6.bytecode_read_raf.point.BytecodeRa_0.address.zero_pad|stage6.bytecode_read_raf.point.BytecodeRa_0.address.source" }, - Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.bytecode_read_raf.point.BytecodeRa_0.address|stage6.bytecode_read_raf.point.Cycle" }, - Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.bytecode_read_raf.point.BytecodeRa_1.address|stage6.bytecode_read_raf.point.Cycle" }, - Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.bytecode_read_raf.point.BytecodeRa_2.address|stage6.bytecode_read_raf.point.Cycle" }, - Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.ram_ra_virtual.point.RamRa_0.address|stage6.ram_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.ram_ra_virtual.point.RamRa_1.address|stage6.ram_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.ram_ra_virtual.point.RamRa_2.address|stage6.ram_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_3", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.ram_ra_virtual.point.RamRa_3.address|stage6.ram_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_0.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_1.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_2.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_3", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_3.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_4", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_4.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_5", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_5.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_6", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_6.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_7", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_7.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_8", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_8.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_9", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_9.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_10", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_10.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_11", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_11.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_12", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_12.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_13", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_13.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_14", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_14.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_15", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_15.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_16", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_16.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_17", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_17.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_18", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_18.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_19", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_19.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_20", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_20.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_21", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_21.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_22", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_22.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_23", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_23.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_24", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_24.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_25", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_25.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_26", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_26.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_27", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_27.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_28", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_28.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_29.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_30.address|stage6.instruction_ra_virtual.instance" }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage6.instruction_ra_virtual.point.InstructionRa_31.address|stage6.instruction_ra_virtual.instance" }, + Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address", layout: "left_zero_padded_address_chunk", arity: 4, inputs: &["stage6.bytecode_read_raf.point.BytecodeRa_0.address.zero_pad", "stage6.bytecode_read_raf.point.BytecodeRa_0.address.source"] }, + Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.bytecode_read_raf.point.BytecodeRa_0.address", "stage6.bytecode_read_raf.point.Cycle"] }, + Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.bytecode_read_raf.point.BytecodeRa_1.address", "stage6.bytecode_read_raf.point.Cycle"] }, + Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.bytecode_read_raf.point.BytecodeRa_2.address", "stage6.bytecode_read_raf.point.Cycle"] }, + Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.ram_ra_virtual.point.RamRa_0.address", "stage6.ram_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.ram_ra_virtual.point.RamRa_1.address", "stage6.ram_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.ram_ra_virtual.point.RamRa_2.address", "stage6.ram_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_3", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.ram_ra_virtual.point.RamRa_3.address", "stage6.ram_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_0.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_1.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_2.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_3", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_3.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_4", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_4.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_5", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_5.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_6", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_6.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_7", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_7.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_8", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_8.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_9", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_9.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_10", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_10.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_11", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_11.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_12", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_12.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_13", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_13.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_14", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_14.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_15", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_15.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_16", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_16.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_17", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_17.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_18", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_18.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_19", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_19.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_20", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_20.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_21", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_21.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_22", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_22.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_23", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_23.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_24", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_24.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_25", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_25.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_26", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_26.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_27", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_27.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_28", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_28.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_29.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_30.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_31.address", "stage6.instruction_ra_virtual.instance"] }, ]; pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[ Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.bytecode_read_raf.point.BytecodeRa_0", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_0" }, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 39f8954edc..739448c99e 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -255,7 +255,7 @@ pub const STAGE7_POINT_SLICES: &[Stage7PointSlicePlan] = &[ ]; pub const STAGE7_POINT_CONCATS: &[Stage7PointConcatPlan] = &[ - Stage7PointConcatPlan { symbol: "stage7.hamming_weight_claim_reduction.point", layout: "address_chunk_then_cycle", arity: 20, inputs: "stage7.hamming_weight_claim_reduction.instance|stage7.hamming_weight_claim_reduction.point.cycle" }, + Stage7PointConcatPlan { symbol: "stage7.hamming_weight_claim_reduction.point", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage7.hamming_weight_claim_reduction.instance", "stage7.hamming_weight_claim_reduction.point.cycle"] }, ]; pub const STAGE7_OPENING_CLAIMS: &[Stage7OpeningClaimPlan] = &[ Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0" }, From dd53841c9d181b326bc4bfedb5ab2bac71640d38 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 19:12:18 -0600 Subject: [PATCH 009/171] refactor(equivalence): clarify generated plan adapters --- crates/jolt-equivalence/src/plan_adapters.rs | 373 ++++++++++--------- 1 file changed, 189 insertions(+), 184 deletions(-) diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 18e88144df..320583fe43 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -4,12 +4,6 @@ //! Bolt's owned compiler plans into the currently generated static plan shape //! expected by jolt-kernels, jolt-prover, and jolt-verifier. -macro_rules! stage_batch_list { - ($mode:ident, $values:expr) => { - super::leak_str_slice($values) - }; -} - macro_rules! stage_field_expr { (kernel, $module:ident, $field_expr:ident, $plan:ident) => { $module::$field_expr { @@ -23,12 +17,21 @@ macro_rules! stage_field_expr { (generated, $module:ident, $field_expr:ident, $plan:ident) => { $module::$field_expr { symbol: super::leak_str(&$plan.symbol), - kind: generated_field_expr_kind!($plan.formula.as_str()), + kind: super::generated_field_expr_kind($plan.formula.as_str()), operands: super::leak_str_slice(&$plan.operands), } }; } +macro_rules! stage_optional_relation_kind { + (kernel, $value:expr) => { + $value.map(super::leak_str) + }; + (generated, $value:expr) => { + $value.map(super::generated_relation_kind) + }; +} + macro_rules! stage_claim { (kernel, $module:ident, $claim:ident, $plan:ident) => { $module::$claim { @@ -41,7 +44,7 @@ macro_rules! stage_claim { kernel: $plan.kernel.as_deref().map(super::leak_str), relation: $plan.relation.as_deref().map(super::leak_str), claim_value: super::leak_str(&$plan.claim_value), - input_openings: stage_batch_list!(kernel, &$plan.input_openings), + input_openings: super::leak_str_slice(&$plan.input_openings), } }; (generated, $module:ident, $claim:ident, $plan:ident) => { @@ -53,12 +56,9 @@ macro_rules! stage_claim { degree: $plan.degree, claim: super::leak_str(&$plan.claim), kernel: $plan.kernel.as_deref().map(super::leak_str), - relation: $plan - .relation - .as_deref() - .map(|relation| generated_relation_kind!(relation)), + relation: stage_optional_relation_kind!(generated, $plan.relation.as_deref()), claim_value: super::leak_str(&$plan.claim_value), - input_openings: stage_batch_list!(generated, &$plan.input_openings), + input_openings: super::leak_str_slice(&$plan.input_openings), } }; } @@ -86,10 +86,7 @@ macro_rules! stage_driver { stage: super::leak_str(&$plan.stage), proof_slot: super::leak_str(&$plan.proof_slot), kernel: $plan.kernel.as_deref().map(super::leak_str), - relation: $plan - .relation - .as_deref() - .map(|relation| generated_relation_kind!(relation)), + relation: stage_optional_relation_kind!(generated, $plan.relation.as_deref()), batch: super::leak_str(&$plan.batch), policy: super::leak_str(&$plan.policy), round_schedule: super::leak_usize_slice(&$plan.round_schedule), @@ -101,174 +98,182 @@ macro_rules! stage_driver { }; } -macro_rules! generated_program_step_kind { - ($value:expr) => { - match $value { - "transcript_squeeze" => { - jolt_verifier::stages::common::ProgramStepKind::TranscriptSqueeze - } - "transcript_absorb_bytes" => { - jolt_verifier::stages::common::ProgramStepKind::TranscriptAbsorbBytes - } - "sumcheck_driver" => jolt_verifier::stages::common::ProgramStepKind::SumcheckDriver, - value => panic!("unsupported generated program step kind `{value}`"), +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_program_step_kind(value: &str) -> jolt_verifier::stages::common::ProgramStepKind { + match value { + "transcript_squeeze" => jolt_verifier::stages::common::ProgramStepKind::TranscriptSqueeze, + "transcript_absorb_bytes" => { + jolt_verifier::stages::common::ProgramStepKind::TranscriptAbsorbBytes } - }; + "sumcheck_driver" => jolt_verifier::stages::common::ProgramStepKind::SumcheckDriver, + value => panic!("unsupported generated program step kind `{value}`"), + } } -macro_rules! generated_transcript_squeeze_kind { - ($value:expr) => { - match $value { - "challenge_scalar" => { - jolt_verifier::stages::common::TranscriptSqueezeKind::ChallengeScalar - } - "challenge_vector" => { - jolt_verifier::stages::common::TranscriptSqueezeKind::ChallengeVector - } - "scalar" => jolt_verifier::stages::common::TranscriptSqueezeKind::Scalar, - value => panic!("unsupported generated transcript squeeze kind `{value}`"), - } - }; +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_transcript_squeeze_kind( + value: &str, +) -> jolt_verifier::stages::common::TranscriptSqueezeKind { + match value { + "challenge_scalar" => jolt_verifier::stages::common::TranscriptSqueezeKind::ChallengeScalar, + "challenge_vector" => jolt_verifier::stages::common::TranscriptSqueezeKind::ChallengeVector, + "scalar" => jolt_verifier::stages::common::TranscriptSqueezeKind::Scalar, + value => panic!("unsupported generated transcript squeeze kind `{value}`"), + } } -macro_rules! generated_claim_kind { - ($value:expr) => { - match $value { - "committed" => jolt_verifier::stages::common::ClaimKind::Committed, - "virtual" => jolt_verifier::stages::common::ClaimKind::Virtual, - value => panic!("unsupported generated claim kind `{value}`"), - } - }; +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_claim_kind(value: &str) -> jolt_verifier::stages::common::ClaimKind { + match value { + "committed" => jolt_verifier::stages::common::ClaimKind::Committed, + "virtual" => jolt_verifier::stages::common::ClaimKind::Virtual, + value => panic!("unsupported generated claim kind `{value}`"), + } } -macro_rules! generated_relation_kind { - ($value:expr) => { - match $value { - "jolt.stage1.outer.uniskip" => { - jolt_verifier::stages::common::RelationKind::Stage1OuterUniskip - } - "jolt.stage1.outer.remaining" => { - jolt_verifier::stages::common::RelationKind::Stage1OuterRemaining - } - "jolt.stage2.product_virtual.uniskip" => { - jolt_verifier::stages::common::RelationKind::Stage2ProductVirtualUniskip - } - "jolt.stage2.ram.read_write" => { - jolt_verifier::stages::common::RelationKind::Stage2RamReadWrite - } - "jolt.stage2.product_virtual.remainder" => { - jolt_verifier::stages::common::RelationKind::Stage2ProductVirtualRemainder - } - "jolt.stage2.instruction_lookup.claim_reduction" => { - jolt_verifier::stages::common::RelationKind::Stage2InstructionLookupClaimReduction - } - "jolt.stage2.ram.raf_evaluation" => { - jolt_verifier::stages::common::RelationKind::Stage2RamRafEvaluation - } - "jolt.stage2.ram.output_check" => { - jolt_verifier::stages::common::RelationKind::Stage2RamOutputCheck - } - "jolt.stage2.batched" => jolt_verifier::stages::common::RelationKind::Stage2Batched, - "jolt.stage3.spartan_shift" => { - jolt_verifier::stages::common::RelationKind::Stage3SpartanShift - } - "jolt.stage3.instruction_input" => { - jolt_verifier::stages::common::RelationKind::Stage3InstructionInput - } - "jolt.stage3.registers_claim_reduction" => { - jolt_verifier::stages::common::RelationKind::Stage3RegistersClaimReduction - } - "jolt.stage3.batched" => jolt_verifier::stages::common::RelationKind::Stage3Batched, - "jolt.stage4.registers_read_write" => { - jolt_verifier::stages::common::RelationKind::Stage4RegistersReadWrite - } - "jolt.stage4.ram_val_check" => { - jolt_verifier::stages::common::RelationKind::Stage4RamValCheck - } - "jolt.stage4.batched" => jolt_verifier::stages::common::RelationKind::Stage4Batched, - "jolt.stage5.instruction_read_raf" => { - jolt_verifier::stages::common::RelationKind::Stage5InstructionReadRaf - } - "jolt.stage5.ram_ra_claim_reduction" => { - jolt_verifier::stages::common::RelationKind::Stage5RamRaClaimReduction - } - "jolt.stage5.registers_val_evaluation" => { - jolt_verifier::stages::common::RelationKind::Stage5RegistersValEvaluation - } - "jolt.stage5.batched" => jolt_verifier::stages::common::RelationKind::Stage5Batched, - "jolt.stage6.bytecode_read_raf" => { - jolt_verifier::stages::common::RelationKind::Stage6BytecodeReadRaf - } - "jolt.stage6.booleanity" => { - jolt_verifier::stages::common::RelationKind::Stage6Booleanity - } - "jolt.stage6.hamming_booleanity" => { - jolt_verifier::stages::common::RelationKind::Stage6HammingBooleanity - } - "jolt.stage6.ram_ra_virtual" => { - jolt_verifier::stages::common::RelationKind::Stage6RamRaVirtual - } - "jolt.stage6.instruction_ra_virtual" => { - jolt_verifier::stages::common::RelationKind::Stage6InstructionRaVirtual - } - "jolt.stage6.inc_claim_reduction" => { - jolt_verifier::stages::common::RelationKind::Stage6IncClaimReduction - } - "jolt.stage6.batched" => jolt_verifier::stages::common::RelationKind::Stage6Batched, - "jolt.stage7.hamming_weight_claim_reduction" => { - jolt_verifier::stages::common::RelationKind::Stage7HammingWeightClaimReduction - } - "jolt.stage7.batched" => jolt_verifier::stages::common::RelationKind::Stage7Batched, - value => panic!("unsupported generated relation `{value}`"), +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_relation_kind(value: &str) -> jolt_verifier::stages::common::RelationKind { + match value { + "jolt.stage1.outer.uniskip" => { + jolt_verifier::stages::common::RelationKind::Stage1OuterUniskip } - }; + "jolt.stage1.outer.remaining" => { + jolt_verifier::stages::common::RelationKind::Stage1OuterRemaining + } + "jolt.stage2.product_virtual.uniskip" => { + jolt_verifier::stages::common::RelationKind::Stage2ProductVirtualUniskip + } + "jolt.stage2.ram.read_write" => { + jolt_verifier::stages::common::RelationKind::Stage2RamReadWrite + } + "jolt.stage2.product_virtual.remainder" => { + jolt_verifier::stages::common::RelationKind::Stage2ProductVirtualRemainder + } + "jolt.stage2.instruction_lookup.claim_reduction" => { + jolt_verifier::stages::common::RelationKind::Stage2InstructionLookupClaimReduction + } + "jolt.stage2.ram.raf_evaluation" => { + jolt_verifier::stages::common::RelationKind::Stage2RamRafEvaluation + } + "jolt.stage2.ram.output_check" => { + jolt_verifier::stages::common::RelationKind::Stage2RamOutputCheck + } + "jolt.stage2.batched" => jolt_verifier::stages::common::RelationKind::Stage2Batched, + "jolt.stage3.spartan_shift" => { + jolt_verifier::stages::common::RelationKind::Stage3SpartanShift + } + "jolt.stage3.instruction_input" => { + jolt_verifier::stages::common::RelationKind::Stage3InstructionInput + } + "jolt.stage3.registers_claim_reduction" => { + jolt_verifier::stages::common::RelationKind::Stage3RegistersClaimReduction + } + "jolt.stage3.batched" => jolt_verifier::stages::common::RelationKind::Stage3Batched, + "jolt.stage4.registers_read_write" => { + jolt_verifier::stages::common::RelationKind::Stage4RegistersReadWrite + } + "jolt.stage4.ram_val_check" => { + jolt_verifier::stages::common::RelationKind::Stage4RamValCheck + } + "jolt.stage4.batched" => jolt_verifier::stages::common::RelationKind::Stage4Batched, + "jolt.stage5.instruction_read_raf" => { + jolt_verifier::stages::common::RelationKind::Stage5InstructionReadRaf + } + "jolt.stage5.ram_ra_claim_reduction" => { + jolt_verifier::stages::common::RelationKind::Stage5RamRaClaimReduction + } + "jolt.stage5.registers_val_evaluation" => { + jolt_verifier::stages::common::RelationKind::Stage5RegistersValEvaluation + } + "jolt.stage5.batched" => jolt_verifier::stages::common::RelationKind::Stage5Batched, + "jolt.stage6.bytecode_read_raf" => { + jolt_verifier::stages::common::RelationKind::Stage6BytecodeReadRaf + } + "jolt.stage6.booleanity" => jolt_verifier::stages::common::RelationKind::Stage6Booleanity, + "jolt.stage6.hamming_booleanity" => { + jolt_verifier::stages::common::RelationKind::Stage6HammingBooleanity + } + "jolt.stage6.ram_ra_virtual" => { + jolt_verifier::stages::common::RelationKind::Stage6RamRaVirtual + } + "jolt.stage6.instruction_ra_virtual" => { + jolt_verifier::stages::common::RelationKind::Stage6InstructionRaVirtual + } + "jolt.stage6.inc_claim_reduction" => { + jolt_verifier::stages::common::RelationKind::Stage6IncClaimReduction + } + "jolt.stage6.batched" => jolt_verifier::stages::common::RelationKind::Stage6Batched, + "jolt.stage7.hamming_weight_claim_reduction" => { + jolt_verifier::stages::common::RelationKind::Stage7HammingWeightClaimReduction + } + "jolt.stage7.batched" => jolt_verifier::stages::common::RelationKind::Stage7Batched, + value => panic!("unsupported generated relation `{value}`"), + } } -macro_rules! generated_field_expr_kind { - ($value:expr) => {{ - let value = $value; - match value { - "opening_eval" => jolt_verifier::stages::common::FieldExprKind::OpeningEval, - "field.add" => jolt_verifier::stages::common::FieldExprKind::Add, - "field.sub" => jolt_verifier::stages::common::FieldExprKind::Sub, - "field.mul" => jolt_verifier::stages::common::FieldExprKind::Mul, - "field.neg" => jolt_verifier::stages::common::FieldExprKind::Neg, - value if value.starts_with("field.pow:") => { - let exponent = value - .strip_prefix("field.pow:") - .expect("field pow expression has prefix") +#[expect( + clippy::expect_used, + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier field expression tag" +)] +fn generated_field_expr_kind(value: &str) -> jolt_verifier::stages::common::FieldExprKind { + match value { + "opening_eval" => jolt_verifier::stages::common::FieldExprKind::OpeningEval, + "field.add" => jolt_verifier::stages::common::FieldExprKind::Add, + "field.sub" => jolt_verifier::stages::common::FieldExprKind::Sub, + "field.mul" => jolt_verifier::stages::common::FieldExprKind::Mul, + "field.neg" => jolt_verifier::stages::common::FieldExprKind::Neg, + value if value.starts_with("field.pow:") => { + let exponent = value + .strip_prefix("field.pow:") + .expect("field pow expression has prefix") + .parse::() + .expect("field pow expression has usize exponent"); + jolt_verifier::stages::common::FieldExprKind::Pow(exponent) + } + value if value.starts_with("poly.lagrange_basis_eval:") => { + let spec = value + .strip_prefix("poly.lagrange_basis_eval:") + .expect("lagrange expression has prefix"); + let parts = spec.split(':').collect::>(); + assert!(parts.len() == 3, "lagrange expression has three fields"); + jolt_verifier::stages::common::FieldExprKind::LagrangeBasisEval( + parts[0] + .parse::() + .expect("lagrange domain start is i64"), + parts[1] .parse::() - .expect("field pow expression has usize exponent"); - jolt_verifier::stages::common::FieldExprKind::Pow(exponent) - } - value if value.starts_with("poly.lagrange_basis_eval:") => { - let spec = value - .strip_prefix("poly.lagrange_basis_eval:") - .expect("lagrange expression has prefix"); - let parts = spec.split(':').collect::>(); - assert!(parts.len() == 3, "lagrange expression has three fields"); - jolt_verifier::stages::common::FieldExprKind::LagrangeBasisEval( - parts[0] - .parse::() - .expect("lagrange domain start is i64"), - parts[1] - .parse::() - .expect("lagrange domain size is usize"), - parts[2].parse::().expect("lagrange index is usize"), - ) - } - value => panic!("unsupported generated field expression kind `{value}`"), + .expect("lagrange domain size is usize"), + parts[2].parse::().expect("lagrange index is usize"), + ) } - }}; + value => panic!("unsupported generated field expression kind `{value}`"), + } } -macro_rules! generated_opening_equality_mode { - ($value:expr) => { - match $value { - "point_and_eval" => jolt_verifier::stages::common::OpeningEqualityMode::PointAndEval, - value => panic!("unsupported generated opening equality mode `{value}`"), - } - }; +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_opening_equality_mode( + value: &str, +) -> jolt_verifier::stages::common::OpeningEqualityMode { + match value { + "point_and_eval" => jolt_verifier::stages::common::OpeningEqualityMode::PointAndEval, + value => panic!("unsupported generated opening equality mode `{value}`"), + } } macro_rules! stage_program_step_kind { @@ -276,7 +281,7 @@ macro_rules! stage_program_step_kind { super::leak_str($value) }; (generated, $module:ident, $value:expr) => { - generated_program_step_kind!($value) + super::generated_program_step_kind($value) }; } @@ -285,7 +290,7 @@ macro_rules! stage_transcript_squeeze_kind { super::leak_str($value) }; (generated, $module:ident, $value:expr) => { - generated_transcript_squeeze_kind!($value) + super::generated_transcript_squeeze_kind($value) }; } @@ -294,7 +299,7 @@ macro_rules! stage_claim_kind { super::leak_str($value) }; (generated, $module:ident, $value:expr) => { - generated_claim_kind!($value) + super::generated_claim_kind($value) }; } @@ -303,7 +308,7 @@ macro_rules! stage_relation_kind { super::leak_str($value) }; (generated, $module:ident, $value:expr) => { - generated_relation_kind!($value) + super::generated_relation_kind($value) }; } @@ -312,7 +317,7 @@ macro_rules! stage_opening_equality_mode { super::leak_str($value) }; (generated, $module:ident, $value:expr) => { - generated_opening_equality_mode!($value) + super::generated_opening_equality_mode($value) }; } @@ -454,8 +459,8 @@ macro_rules! define_stage_adapter_impl { proof_slot: super::leak_str(&plan.proof_slot), policy: super::leak_str(&plan.policy), count: plan.count, - ordered_claims: stage_batch_list!($mode, &plan.ordered_claims), - claim_operands: stage_batch_list!($mode, &plan.claim_operands), + ordered_claims: super::leak_str_slice(&plan.ordered_claims), + claim_operands: super::leak_str_slice(&plan.claim_operands), claim_label: super::leak_str(&plan.claim_label), round_label: super::leak_str(&plan.round_label), round_schedule: super::leak_usize_slice(&plan.round_schedule), @@ -577,8 +582,8 @@ macro_rules! define_stage_adapter_impl { proof_slot: super::leak_str(&plan.proof_slot), policy: super::leak_str(&plan.policy), count: plan.count, - ordered_claims: stage_batch_list!($mode, &plan.ordered_claims), - claim_operands: stage_batch_list!($mode, &plan.claim_operands), + ordered_claims: super::leak_str_slice(&plan.ordered_claims), + claim_operands: super::leak_str_slice(&plan.claim_operands), }) .collect(), ), @@ -765,8 +770,8 @@ macro_rules! define_stage1_adapter { proof_slot: super::leak_str(&plan.proof_slot), policy: super::leak_str(&plan.policy), count: plan.count, - ordered_claims: stage_batch_list!($mode, &plan.ordered_claims), - claim_operands: stage_batch_list!($mode, &plan.claim_operands), + ordered_claims: super::leak_str_slice(&plan.ordered_claims), + claim_operands: super::leak_str_slice(&plan.claim_operands), claim_label: super::leak_str(&plan.claim_label), round_label: super::leak_str(&plan.round_label), round_schedule: super::leak_usize_slice(&plan.round_schedule), @@ -836,8 +841,8 @@ macro_rules! define_stage1_adapter { proof_slot: super::leak_str(&plan.proof_slot), policy: super::leak_str(&plan.policy), count: plan.count, - ordered_claims: stage_batch_list!($mode, &plan.ordered_claims), - claim_operands: stage_batch_list!($mode, &plan.claim_operands), + ordered_claims: super::leak_str_slice(&plan.ordered_claims), + claim_operands: super::leak_str_slice(&plan.claim_operands), }) .collect(), ), From 43b8c22cee22234a45d6edfb652ed16055f9e258 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 19:28:02 -0600 Subject: [PATCH 010/171] refactor(bolt): compact stage8 opening plans --- .../src/protocols/jolt/emit/rust/stage8.rs | 66 +++++- crates/jolt-prover/src/stages/stage8.rs | 210 +++++++++++------- crates/jolt-verifier/src/stages/stage8.rs | 210 +++++++++++------- 3 files changed, 306 insertions(+), 180 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs index 326c2f6ece..947667de98 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs @@ -333,6 +333,7 @@ impl Stage8CpuProgram { source.push_str( "pub struct Stage8EvaluationProgramPlan {\n pub role: &'static str,\n pub function: &'static str,\n pub params: Stage8Params,\n pub evaluation_point_source: Stage8OpeningInputPlan,\n pub opening_inputs: &'static [Stage8OpeningInputPlan],\n pub opening_claims: &'static [Stage8OpeningClaimPlan],\n pub opening_batch: Stage8OpeningBatchPlan,\n pub pcs_proof: Stage8PcsProofPlan,\n}\n\n", ); + source.push_str(stage8_plan_constructors()); source.push_str(stage8_evaluation_helpers()); push_format( @@ -415,6 +416,52 @@ fn params_literal(params: &Stage8Params) -> String { ) } +fn stage8_plan_constructors() -> &'static str { + r"const fn stage8_opening_input( + symbol: &'static str, + source_stage: Stage8SourceStage, + source_claim: &'static str, + oracle: &'static str, + domain: &'static str, + point_arity: usize, + claim_kind: Stage8ClaimKind, +) -> Stage8OpeningInputPlan { + Stage8OpeningInputPlan { + symbol: Stage8OpeningInputSymbol::new(symbol), + source_stage, + source_claim: Stage8SourceClaim::new(source_claim), + oracle, + domain, + point_arity, + claim_kind, + } +} + +const fn stage8_opening_claim( + symbol: &'static str, + oracle: &'static str, + family: &'static str, + domain: &'static str, + point_arity: usize, + input_symbol: &'static str, + source: (Stage8SourceStage, &'static str), +) -> Stage8OpeningClaimPlan { + Stage8OpeningClaimPlan { + symbol: Stage8OpeningClaimSymbol::new(symbol), + oracle, + family, + domain, + point_arity, + point_source: Stage8OpeningInputSymbol::new(input_symbol), + eval_source: Stage8OpeningInputSymbol::new(input_symbol), + source_stage: source.0, + source_claim: Stage8SourceClaim::new(source.1), + } +} + +" +} + fn prover_local_plan_types() -> &'static str { r#"#[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8Params { @@ -693,10 +740,10 @@ where fn opening_input_literal(input: &Stage8OpeningInputPlan) -> Result { Ok(format!( - "Stage8OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }}", - symbol_expr("Stage8OpeningInputSymbol", &input.symbol), + "stage8_opening_input({}, {}, {}, {}, {}, {}, {})", + rust_str(&input.symbol), source_stage_expr(&input.source_stage)?, - source_claim_expr(&input.source_claim), + rust_str(&input.source_claim), rust_str(&input.oracle), rust_str(&input.domain), input.point_arity, @@ -706,16 +753,15 @@ fn opening_input_literal(input: &Stage8OpeningInputPlan) -> Result Result { Ok(format!( - "Stage8OpeningClaimPlan {{ symbol: {}, oracle: {}, family: {}, domain: {}, point_arity: {}, point_source: {}, eval_source: {}, source_stage: {}, source_claim: {} }}", - symbol_expr("Stage8OpeningClaimSymbol", &claim.symbol), + "stage8_opening_claim({}, {}, {}, {}, {}, {}, ({}, {}))", + rust_str(&claim.symbol), rust_str(&claim.oracle), rust_str(&claim.family), rust_str(&claim.domain), claim.point_arity, - symbol_expr("Stage8OpeningInputSymbol", &claim.point_source), - symbol_expr("Stage8OpeningInputSymbol", &claim.eval_source), + rust_str(&claim.point_source), source_stage_expr(&claim.source_stage)?, - source_claim_expr(&claim.source_claim), + rust_str(&claim.source_claim), )) } @@ -736,10 +782,6 @@ fn symbol_expr(type_name: &str, symbol: &str) -> String { format!("{type_name}::new({})", rust_str(symbol)) } -fn source_claim_expr(source_claim: &str) -> String { - format!("Stage8SourceClaim::new({})", rust_str(source_claim)) -} - fn opening_batch_literal(batch: &Stage8OpeningBatchPlan) -> String { format!( "Stage8OpeningBatchPlan {{ symbol: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: STAGE8_OPENING_CLAIMS }}", diff --git a/crates/jolt-prover/src/stages/stage8.rs b/crates/jolt-prover/src/stages/stage8.rs index 6726f6e596..1ad54c149a 100644 --- a/crates/jolt-prover/src/stages/stage8.rs +++ b/crates/jolt-prover/src/stages/stage8.rs @@ -141,6 +141,48 @@ pub struct Stage8EvaluationProgramPlan { pub pcs_proof: Stage8PcsProofPlan, } +const fn stage8_opening_input( + symbol: &'static str, + source_stage: Stage8SourceStage, + source_claim: &'static str, + oracle: &'static str, + domain: &'static str, + point_arity: usize, + claim_kind: Stage8ClaimKind, +) -> Stage8OpeningInputPlan { + Stage8OpeningInputPlan { + symbol: Stage8OpeningInputSymbol::new(symbol), + source_stage, + source_claim: Stage8SourceClaim::new(source_claim), + oracle, + domain, + point_arity, + claim_kind, + } +} + +const fn stage8_opening_claim( + symbol: &'static str, + oracle: &'static str, + family: &'static str, + domain: &'static str, + point_arity: usize, + input_symbol: &'static str, + source: (Stage8SourceStage, &'static str), +) -> Stage8OpeningClaimPlan { + Stage8OpeningClaimPlan { + symbol: Stage8OpeningClaimSymbol::new(symbol), + oracle, + family, + domain, + point_arity, + point_source: Stage8OpeningInputSymbol::new(input_symbol), + eval_source: Stage8OpeningInputSymbol::new(input_symbol), + source_stage: source.0, + source_claim: Stage8SourceClaim::new(source.1), + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8EvaluationClaim { pub oracle: &'static str, @@ -331,97 +373,97 @@ where pub const STAGE8_PARAMS: Stage8Params = Stage8Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; -pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.evaluation.point_source"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.input.stage6.booleanity.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }; +pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = stage8_opening_input("stage8.evaluation.point_source", Stage8SourceStage::Stage7, "stage7.input.stage6.booleanity.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed); #[rustfmt::skip] pub const STAGE8_OPENING_INPUTS: &[Stage8OpeningInputPlan] = &[ - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.evaluation.point_source"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.input.stage6.booleanity.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RamInc"), oracle: "RamInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RdInc"), oracle: "RdInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1"), oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2"), oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3"), oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4"), oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5"), oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6"), oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7"), oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8"), oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9"), oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10"), oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11"), oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12"), oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13"), oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14"), oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15"), oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16"), oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17"), oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18"), oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19"), oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20"), oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21"), oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22"), oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23"), oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24"), oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25"), oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26"), oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27"), oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28"), oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29"), oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30"), oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31"), oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0"), oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1"), oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2"), oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_0"), oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_1"), oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_2"), oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_3"), oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + stage8_opening_input("stage8.evaluation.point_source", Stage8SourceStage::Stage7, "stage7.input.stage6.booleanity.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage6.RamInc", Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RamInc", "RamInc", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage6.RdInc", Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RdInc", "RdInc", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "InstructionRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "InstructionRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_3", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "InstructionRa_3", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_4", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "InstructionRa_4", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_5", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "InstructionRa_5", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_6", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "InstructionRa_6", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_7", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "InstructionRa_7", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_8", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "InstructionRa_8", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_9", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "InstructionRa_9", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_10", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "InstructionRa_10", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_11", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "InstructionRa_11", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_12", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "InstructionRa_12", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_13", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "InstructionRa_13", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_14", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "InstructionRa_14", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_15", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "InstructionRa_15", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_16", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "InstructionRa_16", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_17", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "InstructionRa_17", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_18", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "InstructionRa_18", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_19", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "InstructionRa_19", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_20", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "InstructionRa_20", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_21", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "InstructionRa_21", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_22", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "InstructionRa_22", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_23", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "InstructionRa_23", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_24", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "InstructionRa_24", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_25", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "InstructionRa_25", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_26", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "InstructionRa_26", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_27", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "InstructionRa_27", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_28", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "InstructionRa_28", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_29", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "InstructionRa_29", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_30", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "InstructionRa_30", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_31", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "InstructionRa_31", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.BytecodeRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "BytecodeRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.BytecodeRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "BytecodeRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.BytecodeRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "BytecodeRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.RamRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "RamRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.RamRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "RamRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.RamRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "RamRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.RamRa_3", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "RamRa_3", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), ]; #[rustfmt::skip] pub const STAGE8_OPENING_CLAIMS: &[Stage8OpeningClaimPlan] = &[ - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamInc"), oracle: "RamInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RamInc") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RdInc"), oracle: "RdInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RdInc") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_0"), oracle: "InstructionRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_1"), oracle: "InstructionRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_2"), oracle: "InstructionRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_3"), oracle: "InstructionRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_4"), oracle: "InstructionRa_4", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_5"), oracle: "InstructionRa_5", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_6"), oracle: "InstructionRa_6", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_7"), oracle: "InstructionRa_7", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_8"), oracle: "InstructionRa_8", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_9"), oracle: "InstructionRa_9", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_10"), oracle: "InstructionRa_10", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_11"), oracle: "InstructionRa_11", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_12"), oracle: "InstructionRa_12", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_13"), oracle: "InstructionRa_13", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_14"), oracle: "InstructionRa_14", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_15"), oracle: "InstructionRa_15", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_16"), oracle: "InstructionRa_16", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_17"), oracle: "InstructionRa_17", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_18"), oracle: "InstructionRa_18", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_19"), oracle: "InstructionRa_19", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_20"), oracle: "InstructionRa_20", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_21"), oracle: "InstructionRa_21", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_22"), oracle: "InstructionRa_22", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_23"), oracle: "InstructionRa_23", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_24"), oracle: "InstructionRa_24", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_25"), oracle: "InstructionRa_25", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_26"), oracle: "InstructionRa_26", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_27"), oracle: "InstructionRa_27", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_28"), oracle: "InstructionRa_28", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_29"), oracle: "InstructionRa_29", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_30"), oracle: "InstructionRa_30", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_31"), oracle: "InstructionRa_31", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_0"), oracle: "BytecodeRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_1"), oracle: "BytecodeRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_2"), oracle: "BytecodeRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_0"), oracle: "RamRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_0") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_1"), oracle: "RamRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_1") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_2"), oracle: "RamRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_2") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_3"), oracle: "RamRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_3") }, + stage8_opening_claim("stage8.evaluation.opening.RamInc", "RamInc", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage6.RamInc", (Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RamInc")), + stage8_opening_claim("stage8.evaluation.opening.RdInc", "RdInc", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage6.RdInc", (Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RdInc")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_1", "InstructionRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_2", "InstructionRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_3", "InstructionRa_3", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_3", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_4", "InstructionRa_4", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_4", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_5", "InstructionRa_5", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_5", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_6", "InstructionRa_6", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_6", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_7", "InstructionRa_7", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_7", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_8", "InstructionRa_8", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_8", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_9", "InstructionRa_9", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_9", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_10", "InstructionRa_10", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_10", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_11", "InstructionRa_11", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_11", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_12", "InstructionRa_12", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_12", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_13", "InstructionRa_13", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_13", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_14", "InstructionRa_14", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_14", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_15", "InstructionRa_15", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_15", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_16", "InstructionRa_16", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_16", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_17", "InstructionRa_17", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_17", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_18", "InstructionRa_18", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_18", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_19", "InstructionRa_19", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_19", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_20", "InstructionRa_20", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_20", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_21", "InstructionRa_21", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_21", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_22", "InstructionRa_22", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_22", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_23", "InstructionRa_23", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_23", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_24", "InstructionRa_24", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_24", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_25", "InstructionRa_25", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_25", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_26", "InstructionRa_26", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_26", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_27", "InstructionRa_27", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_27", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_28", "InstructionRa_28", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_28", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_29", "InstructionRa_29", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_29", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_30", "InstructionRa_30", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_30", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_31", "InstructionRa_31", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_31", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31")), + stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_0", "BytecodeRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0")), + stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_1", "BytecodeRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1")), + stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_2", "BytecodeRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2")), + stage8_opening_claim("stage8.evaluation.opening.RamRa_0", "RamRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_0")), + stage8_opening_claim("stage8.evaluation.opening.RamRa_1", "RamRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_1")), + stage8_opening_claim("stage8.evaluation.opening.RamRa_2", "RamRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_2")), + stage8_opening_claim("stage8.evaluation.opening.RamRa_3", "RamRa_3", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_3", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_3")), ]; #[rustfmt::skip] diff --git a/crates/jolt-verifier/src/stages/stage8.rs b/crates/jolt-verifier/src/stages/stage8.rs index 7f4ce85a4d..afd2239aac 100644 --- a/crates/jolt-verifier/src/stages/stage8.rs +++ b/crates/jolt-verifier/src/stages/stage8.rs @@ -70,6 +70,48 @@ pub struct Stage8EvaluationProgramPlan { pub pcs_proof: Stage8PcsProofPlan, } +const fn stage8_opening_input( + symbol: &'static str, + source_stage: Stage8SourceStage, + source_claim: &'static str, + oracle: &'static str, + domain: &'static str, + point_arity: usize, + claim_kind: Stage8ClaimKind, +) -> Stage8OpeningInputPlan { + Stage8OpeningInputPlan { + symbol: Stage8OpeningInputSymbol::new(symbol), + source_stage, + source_claim: Stage8SourceClaim::new(source_claim), + oracle, + domain, + point_arity, + claim_kind, + } +} + +const fn stage8_opening_claim( + symbol: &'static str, + oracle: &'static str, + family: &'static str, + domain: &'static str, + point_arity: usize, + input_symbol: &'static str, + source: (Stage8SourceStage, &'static str), +) -> Stage8OpeningClaimPlan { + Stage8OpeningClaimPlan { + symbol: Stage8OpeningClaimSymbol::new(symbol), + oracle, + family, + domain, + point_arity, + point_source: Stage8OpeningInputSymbol::new(input_symbol), + eval_source: Stage8OpeningInputSymbol::new(input_symbol), + source_stage: source.0, + source_claim: Stage8SourceClaim::new(source.1), + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage8EvaluationClaim { pub oracle: &'static str, @@ -260,97 +302,97 @@ where pub const STAGE8_PARAMS: Stage8Params = Stage8Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; -pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.evaluation.point_source"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.input.stage6.booleanity.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }; +pub const STAGE8_EVALUATION_POINT_SOURCE: Stage8OpeningInputPlan = stage8_opening_input("stage8.evaluation.point_source", Stage8SourceStage::Stage7, "stage7.input.stage6.booleanity.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed); #[rustfmt::skip] pub const STAGE8_OPENING_INPUTS: &[Stage8OpeningInputPlan] = &[ - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.evaluation.point_source"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.input.stage6.booleanity.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RamInc"), oracle: "RamInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RdInc"), oracle: "RdInc", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0"), oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1"), oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2"), oracle: "InstructionRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3"), oracle: "InstructionRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4"), oracle: "InstructionRa_4", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5"), oracle: "InstructionRa_5", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6"), oracle: "InstructionRa_6", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7"), oracle: "InstructionRa_7", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8"), oracle: "InstructionRa_8", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9"), oracle: "InstructionRa_9", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10"), oracle: "InstructionRa_10", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11"), oracle: "InstructionRa_11", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12"), oracle: "InstructionRa_12", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13"), oracle: "InstructionRa_13", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14"), oracle: "InstructionRa_14", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15"), oracle: "InstructionRa_15", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16"), oracle: "InstructionRa_16", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17"), oracle: "InstructionRa_17", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18"), oracle: "InstructionRa_18", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19"), oracle: "InstructionRa_19", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20"), oracle: "InstructionRa_20", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21"), oracle: "InstructionRa_21", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22"), oracle: "InstructionRa_22", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23"), oracle: "InstructionRa_23", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24"), oracle: "InstructionRa_24", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25"), oracle: "InstructionRa_25", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26"), oracle: "InstructionRa_26", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27"), oracle: "InstructionRa_27", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28"), oracle: "InstructionRa_28", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29"), oracle: "InstructionRa_29", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30"), oracle: "InstructionRa_30", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31"), oracle: "InstructionRa_31", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0"), oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1"), oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2"), oracle: "BytecodeRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_0"), oracle: "RamRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_1"), oracle: "RamRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_2"), oracle: "RamRa_2", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, - Stage8OpeningInputPlan { symbol: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_3"), oracle: "RamRa_3", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage8ClaimKind::Committed }, + stage8_opening_input("stage8.evaluation.point_source", Stage8SourceStage::Stage7, "stage7.input.stage6.booleanity.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage6.RamInc", Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RamInc", "RamInc", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage6.RdInc", Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RdInc", "RdInc", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "InstructionRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "InstructionRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_3", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "InstructionRa_3", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_4", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "InstructionRa_4", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_5", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "InstructionRa_5", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_6", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "InstructionRa_6", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_7", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "InstructionRa_7", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_8", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "InstructionRa_8", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_9", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "InstructionRa_9", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_10", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "InstructionRa_10", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_11", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "InstructionRa_11", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_12", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "InstructionRa_12", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_13", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "InstructionRa_13", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_14", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "InstructionRa_14", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_15", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "InstructionRa_15", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_16", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "InstructionRa_16", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_17", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "InstructionRa_17", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_18", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "InstructionRa_18", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_19", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "InstructionRa_19", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_20", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "InstructionRa_20", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_21", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "InstructionRa_21", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_22", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "InstructionRa_22", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_23", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "InstructionRa_23", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_24", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "InstructionRa_24", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_25", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "InstructionRa_25", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_26", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "InstructionRa_26", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_27", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "InstructionRa_27", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_28", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "InstructionRa_28", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_29", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "InstructionRa_29", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_30", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "InstructionRa_30", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.InstructionRa_31", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "InstructionRa_31", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.BytecodeRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "BytecodeRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.BytecodeRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "BytecodeRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.BytecodeRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "BytecodeRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.RamRa_0", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "RamRa_0", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.RamRa_1", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "RamRa_1", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.RamRa_2", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "RamRa_2", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), + stage8_opening_input("stage8.input.stage7.RamRa_3", Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "RamRa_3", "jolt.main_witness_commit_domain", 20, Stage8ClaimKind::Committed), ]; #[rustfmt::skip] pub const STAGE8_OPENING_CLAIMS: &[Stage8OpeningClaimPlan] = &[ - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamInc"), oracle: "RamInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RamInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RamInc") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RdInc"), oracle: "RdInc", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage6.RdInc"), source_stage: Stage8SourceStage::Stage6, source_claim: Stage8SourceClaim::new("stage6.inc_claim_reduction.eval.RdInc") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_0"), oracle: "InstructionRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_1"), oracle: "InstructionRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_2"), oracle: "InstructionRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_3"), oracle: "InstructionRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_4"), oracle: "InstructionRa_4", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_4"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_5"), oracle: "InstructionRa_5", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_5"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_6"), oracle: "InstructionRa_6", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_6"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_7"), oracle: "InstructionRa_7", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_7"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_8"), oracle: "InstructionRa_8", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_8"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_9"), oracle: "InstructionRa_9", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_9"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_10"), oracle: "InstructionRa_10", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_10"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_11"), oracle: "InstructionRa_11", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_11"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_12"), oracle: "InstructionRa_12", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_12"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_13"), oracle: "InstructionRa_13", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_13"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_14"), oracle: "InstructionRa_14", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_14"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_15"), oracle: "InstructionRa_15", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_15"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_16"), oracle: "InstructionRa_16", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_16"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_17"), oracle: "InstructionRa_17", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_17"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_18"), oracle: "InstructionRa_18", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_18"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_19"), oracle: "InstructionRa_19", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_19"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_20"), oracle: "InstructionRa_20", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_20"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_21"), oracle: "InstructionRa_21", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_21"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_22"), oracle: "InstructionRa_22", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_22"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_23"), oracle: "InstructionRa_23", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_23"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_24"), oracle: "InstructionRa_24", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_24"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_25"), oracle: "InstructionRa_25", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_25"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_26"), oracle: "InstructionRa_26", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_26"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_27"), oracle: "InstructionRa_27", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_27"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_28"), oracle: "InstructionRa_28", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_28"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_29"), oracle: "InstructionRa_29", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_29"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_30"), oracle: "InstructionRa_30", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_30"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.InstructionRa_31"), oracle: "InstructionRa_31", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.InstructionRa_31"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_0"), oracle: "BytecodeRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_1"), oracle: "BytecodeRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.BytecodeRa_2"), oracle: "BytecodeRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.BytecodeRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_0"), oracle: "RamRa_0", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_0"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_0") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_1"), oracle: "RamRa_1", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_1"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_1") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_2"), oracle: "RamRa_2", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_2"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_2") }, - Stage8OpeningClaimPlan { symbol: Stage8OpeningClaimSymbol::new("stage8.evaluation.opening.RamRa_3"), oracle: "RamRa_3", family: "jolt.main_witness_polys", domain: "jolt.main_witness_commit_domain", point_arity: 20, point_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), eval_source: Stage8OpeningInputSymbol::new("stage8.input.stage7.RamRa_3"), source_stage: Stage8SourceStage::Stage7, source_claim: Stage8SourceClaim::new("stage7.hamming_weight_claim_reduction.eval.RamRa_3") }, + stage8_opening_claim("stage8.evaluation.opening.RamInc", "RamInc", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage6.RamInc", (Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RamInc")), + stage8_opening_claim("stage8.evaluation.opening.RdInc", "RdInc", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage6.RdInc", (Stage8SourceStage::Stage6, "stage6.inc_claim_reduction.eval.RdInc")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_0", "InstructionRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_1", "InstructionRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_2", "InstructionRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_3", "InstructionRa_3", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_3", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_4", "InstructionRa_4", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_4", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_5", "InstructionRa_5", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_5", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_6", "InstructionRa_6", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_6", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_7", "InstructionRa_7", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_7", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_8", "InstructionRa_8", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_8", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_9", "InstructionRa_9", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_9", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_10", "InstructionRa_10", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_10", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_11", "InstructionRa_11", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_11", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_12", "InstructionRa_12", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_12", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_13", "InstructionRa_13", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_13", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_14", "InstructionRa_14", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_14", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_15", "InstructionRa_15", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_15", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_16", "InstructionRa_16", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_16", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_17", "InstructionRa_17", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_17", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_18", "InstructionRa_18", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_18", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_19", "InstructionRa_19", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_19", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_20", "InstructionRa_20", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_20", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_21", "InstructionRa_21", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_21", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_22", "InstructionRa_22", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_22", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_23", "InstructionRa_23", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_23", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_24", "InstructionRa_24", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_24", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_25", "InstructionRa_25", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_25", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_26", "InstructionRa_26", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_26", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_27", "InstructionRa_27", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_27", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_28", "InstructionRa_28", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_28", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_29", "InstructionRa_29", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_29", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_30", "InstructionRa_30", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_30", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30")), + stage8_opening_claim("stage8.evaluation.opening.InstructionRa_31", "InstructionRa_31", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.InstructionRa_31", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31")), + stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_0", "BytecodeRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0")), + stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_1", "BytecodeRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1")), + stage8_opening_claim("stage8.evaluation.opening.BytecodeRa_2", "BytecodeRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.BytecodeRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2")), + stage8_opening_claim("stage8.evaluation.opening.RamRa_0", "RamRa_0", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_0", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_0")), + stage8_opening_claim("stage8.evaluation.opening.RamRa_1", "RamRa_1", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_1", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_1")), + stage8_opening_claim("stage8.evaluation.opening.RamRa_2", "RamRa_2", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_2", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_2")), + stage8_opening_claim("stage8.evaluation.opening.RamRa_3", "RamRa_3", "jolt.main_witness_polys", "jolt.main_witness_commit_domain", 20, "stage8.input.stage7.RamRa_3", (Stage8SourceStage::Stage7, "stage7.hamming_weight_claim_reduction.eval.RamRa_3")), ]; #[rustfmt::skip] From 02eda4ae14832fef08f668c42c9d0258e6ddc223 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 19:36:35 -0600 Subject: [PATCH 011/171] refactor(equivalence): harden stage8 plan adapters --- .../src/protocols/jolt/emit/rust/stage8.rs | 108 +++++ crates/jolt-equivalence/src/plan_adapters.rs | 426 +++++++++++++----- 2 files changed, 414 insertions(+), 120 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs index 947667de98..adef9f0d31 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs @@ -898,3 +898,111 @@ fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { .unwrap_or("") .to_owned() } + +#[cfg(test)] +#[expect( + clippy::expect_used, + reason = "tests assert exact Stage 8 validation failures" +)] +mod tests { + use super::*; + + fn valid_verifier_program() -> Stage8CpuProgram { + Stage8CpuProgram { + role: Role::Verifier, + params: Stage8Params { + field: "Fr".to_owned(), + pcs: "Dory".to_owned(), + transcript: "Blake2b".to_owned(), + }, + function: "jolt.stage8".to_owned(), + opening_inputs: vec![ + Stage8OpeningInputPlan { + symbol: EVALUATION_POINT_SOURCE_SYMBOL.to_owned(), + source_stage: "stage7".to_owned(), + source_claim: "stage7.input.stage6.booleanity.InstructionRa_0".to_owned(), + oracle: "InstructionRa_0".to_owned(), + domain: "hamming_weight".to_owned(), + point_arity: 4, + claim_kind: "virtual".to_owned(), + }, + Stage8OpeningInputPlan { + symbol: "stage8.input.stage6.RamInc".to_owned(), + source_stage: "stage6".to_owned(), + source_claim: "stage6.inc_claim_reduction.eval.RamInc".to_owned(), + oracle: "RamInc".to_owned(), + domain: "ram".to_owned(), + point_arity: 4, + claim_kind: "committed".to_owned(), + }, + ], + opening_claims: vec![Stage8OpeningClaimPlan { + symbol: "stage8.evaluation.opening.RamInc".to_owned(), + oracle: "RamInc".to_owned(), + family: "commitment".to_owned(), + domain: "ram".to_owned(), + point_arity: 4, + point_source: "stage8.input.stage6.RamInc".to_owned(), + eval_source: "stage8.input.stage6.RamInc".to_owned(), + source_stage: "stage6".to_owned(), + source_claim: "stage6.inc_claim_reduction.eval.RamInc".to_owned(), + }], + opening_batches: vec![Stage8OpeningBatchPlan { + symbol: "stage8.evaluation.openings".to_owned(), + proof_slot: "@stage8.evaluation".to_owned(), + policy: "jolt_stage8_joint_rlc".to_owned(), + count: 1, + ordered_claims: vec!["stage8.evaluation.opening.RamInc".to_owned()], + claim_operands: vec!["stage8.evaluation.opening.RamInc".to_owned()], + }], + pcs_proofs: vec![Stage8PcsProofPlan { + symbol: "stage8.evaluation.proof".to_owned(), + mode: "verify".to_owned(), + pcs: "dory".to_owned(), + proof_slot: "@stage8.evaluation".to_owned(), + transcript_label: "rlc_claims".to_owned(), + batch: "stage8.evaluation.openings".to_owned(), + }], + } + } + + #[test] + fn stage8_validation_rejects_missing_evaluation_point_source() { + let mut program = valid_verifier_program(); + program + .opening_inputs + .retain(|input| input.symbol != EVALUATION_POINT_SOURCE_SYMBOL); + + let error = program + .verify_supported_target() + .expect_err("missing Stage 8 evaluation point source is rejected"); + + assert!( + error.to_string().contains( + "stage8 program missing `stage8.evaluation.point_source` opening-point source" + ), + "{error}" + ); + } + + #[test] + fn stage8_validation_rejects_split_point_and_eval_sources() { + let mut program = valid_verifier_program(); + program + .opening_claims + .first_mut() + .expect("fixture has an opening claim") + .eval_source = EVALUATION_POINT_SOURCE_SYMBOL.to_owned(); + + let error = program + .verify_supported_target() + .expect_err("split Stage 8 point/eval source is rejected"); + + assert!( + error.to_string().contains( + "stage8 claim `stage8.evaluation.opening.RamInc` must take point and eval from the same opening input" + ), + "{error}" + ); + } +} diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 320583fe43..045d217222 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -890,134 +890,320 @@ use bolt::Role; use jolt_prover::stages::stage8 as generated_prover_stage8; use jolt_verifier::stages::stage8 as generated_stage8; -macro_rules! stage8_source_stage { - ($module:ident, $value:expr) => { - match $value { - "stage6" => $module::Stage8SourceStage::Stage6, - "stage7" => $module::Stage8SourceStage::Stage7, - value => panic!("unsupported Stage 8 source stage `{value}`"), - } - }; +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag" +)] +fn generated_prover_stage8_source_stage(value: &str) -> generated_prover_stage8::Stage8SourceStage { + match value { + "stage6" => generated_prover_stage8::Stage8SourceStage::Stage6, + "stage7" => generated_prover_stage8::Stage8SourceStage::Stage7, + value => panic!("unsupported Stage 8 source stage `{value}`"), + } } -macro_rules! stage8_claim_kind { - ($module:ident, $value:expr) => { - match $value { - "committed" => $module::Stage8ClaimKind::Committed, - "virtual" => $module::Stage8ClaimKind::Virtual, - value => panic!("unsupported Stage 8 claim kind `{value}`"), - } - }; +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag" +)] +fn generated_stage8_source_stage(value: &str) -> generated_stage8::Stage8SourceStage { + match value { + "stage6" => generated_stage8::Stage8SourceStage::Stage6, + "stage7" => generated_stage8::Stage8SourceStage::Stage7, + value => panic!("unsupported Stage 8 source stage `{value}`"), + } } -macro_rules! stage8_pcs_proof_mode { - ($module:ident, $value:expr) => { - match $value { - "open" => $module::Stage8PcsProofMode::Open, - "verify" => $module::Stage8PcsProofMode::Verify, - value => panic!("unsupported Stage 8 PCS proof mode `{value}`"), - } - }; +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag" +)] +fn generated_prover_stage8_claim_kind(value: &str) -> generated_prover_stage8::Stage8ClaimKind { + match value { + "committed" => generated_prover_stage8::Stage8ClaimKind::Committed, + "virtual" => generated_prover_stage8::Stage8ClaimKind::Virtual, + value => panic!("unsupported Stage 8 claim kind `{value}`"), + } } -macro_rules! define_stage8_adapter { - ($function:ident, $module:ident) => { - pub(crate) fn $function( - program: &CompilerStage8CpuProgram, - ) -> &'static $module::Stage8EvaluationProgramPlan { - let opening_inputs = leak_slice( - program - .opening_inputs - .iter() - .map(|plan| $module::Stage8OpeningInputPlan { - symbol: $module::Stage8OpeningInputSymbol::new(leak_str(&plan.symbol)), - source_stage: stage8_source_stage!($module, plan.source_stage.as_str()), - source_claim: $module::Stage8SourceClaim::new(leak_str(&plan.source_claim)), - oracle: leak_str(&plan.oracle), - domain: leak_str(&plan.domain), - point_arity: plan.point_arity, - claim_kind: stage8_claim_kind!($module, plan.claim_kind.as_str()), - }) - .collect(), - ); - let opening_claims = leak_slice( - program - .opening_claims - .iter() - .map(|plan| $module::Stage8OpeningClaimPlan { - symbol: $module::Stage8OpeningClaimSymbol::new(leak_str(&plan.symbol)), - oracle: leak_str(&plan.oracle), - family: leak_str(&plan.family), - domain: leak_str(&plan.domain), - point_arity: plan.point_arity, - point_source: $module::Stage8OpeningInputSymbol::new(leak_str( - &plan.point_source, - )), - eval_source: $module::Stage8OpeningInputSymbol::new(leak_str( - &plan.eval_source, - )), - source_stage: stage8_source_stage!($module, plan.source_stage.as_str()), - source_claim: $module::Stage8SourceClaim::new(leak_str(&plan.source_claim)), - }) - .collect(), - ); - let evaluation_point_source = opening_inputs - .iter() - .find(|input| input.symbol.as_str() == "stage8.evaluation.point_source") - .copied() - .expect("stage8 evaluation point source exists"); - let ordered_claims = leak_slice( - program.opening_batches[0] - .ordered_claims - .iter() - .map(|symbol| { - *opening_claims - .iter() - .find(|claim| claim.symbol.as_str() == symbol) - .expect("stage8 opening batch claim exists") - }) - .collect(), - ); - Box::leak(Box::new($module::Stage8EvaluationProgramPlan { - role: role_name(&program.role), - function: leak_str(&program.function), - params: $module::Stage8Params { - field: leak_str(&program.params.field), - pcs: leak_str(&program.params.pcs), - transcript: leak_str(&program.params.transcript), - }, - evaluation_point_source, - opening_inputs, - opening_claims, - opening_batch: $module::Stage8OpeningBatchPlan { - symbol: $module::Stage8OpeningBatchSymbol::new(leak_str( - &program.opening_batches[0].symbol, - )), - proof_slot: leak_str(&program.opening_batches[0].proof_slot), - policy: leak_str(&program.opening_batches[0].policy), - count: program.opening_batches[0].count, - ordered_claims, - }, - pcs_proof: $module::Stage8PcsProofPlan { - symbol: leak_str(&program.pcs_proofs[0].symbol), - mode: stage8_pcs_proof_mode!($module, program.pcs_proofs[0].mode.as_str()), - pcs: leak_str(&program.pcs_proofs[0].pcs), - proof_slot: leak_str(&program.pcs_proofs[0].proof_slot), - transcript_label: leak_str(&program.pcs_proofs[0].transcript_label), - batch: $module::Stage8OpeningBatchSymbol::new(leak_str( - &program.pcs_proofs[0].batch, - )), - }, - })) - } - }; +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag" +)] +fn generated_stage8_claim_kind(value: &str) -> generated_stage8::Stage8ClaimKind { + match value { + "committed" => generated_stage8::Stage8ClaimKind::Committed, + "virtual" => generated_stage8::Stage8ClaimKind::Virtual, + value => panic!("unsupported Stage 8 claim kind `{value}`"), + } } -define_stage8_adapter!( - leak_generated_stage8_prover_program, - generated_prover_stage8 -); -define_stage8_adapter!(leak_generated_stage8_verifier_program, generated_stage8); +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag" +)] +fn generated_prover_stage8_pcs_proof_mode( + value: &str, +) -> generated_prover_stage8::Stage8PcsProofMode { + match value { + "open" => generated_prover_stage8::Stage8PcsProofMode::Open, + "verify" => generated_prover_stage8::Stage8PcsProofMode::Verify, + value => panic!("unsupported Stage 8 PCS proof mode `{value}`"), + } +} + +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated Stage 8 enum tag" +)] +fn generated_stage8_pcs_proof_mode(value: &str) -> generated_stage8::Stage8PcsProofMode { + match value { + "open" => generated_stage8::Stage8PcsProofMode::Open, + "verify" => generated_stage8::Stage8PcsProofMode::Verify, + value => panic!("unsupported Stage 8 PCS proof mode `{value}`"), + } +} + +#[expect( + clippy::expect_used, + reason = "Stage 8 adapters consume compiler-validated plans and fail fast if required generated plan rows are missing" +)] +fn stage8_evaluation_point_source_index(program: &CompilerStage8CpuProgram) -> usize { + program + .opening_inputs + .iter() + .position(|input| input.symbol == "stage8.evaluation.point_source") + .expect("stage8 evaluation point source exists") +} + +#[expect( + clippy::expect_used, + reason = "Stage 8 adapters consume compiler-validated plans and fail fast if required generated plan rows are missing" +)] +fn stage8_ordered_claim_indices(program: &CompilerStage8CpuProgram) -> Vec { + let claim_index_by_symbol = program + .opening_claims + .iter() + .enumerate() + .map(|(index, claim)| (claim.symbol.as_str(), index)) + .collect::>(); + program + .opening_batches + .first() + .expect("stage8 opening batch exists") + .ordered_claims + .iter() + .map(|symbol| { + *claim_index_by_symbol + .get(symbol.as_str()) + .expect("stage8 opening batch claim exists") + }) + .collect() +} + +#[expect( + clippy::expect_used, + reason = "Stage 8 adapters consume compiler-validated plans and fail fast if required generated plan rows are missing" +)] +pub(crate) fn leak_generated_stage8_prover_program( + program: &CompilerStage8CpuProgram, +) -> &'static generated_prover_stage8::Stage8EvaluationProgramPlan { + let evaluation_point_source_index = stage8_evaluation_point_source_index(program); + let ordered_claim_indices = stage8_ordered_claim_indices(program); + let opening_inputs = leak_slice( + program + .opening_inputs + .iter() + .map(|plan| generated_prover_stage8::Stage8OpeningInputPlan { + symbol: generated_prover_stage8::Stage8OpeningInputSymbol::new(leak_str( + &plan.symbol, + )), + source_stage: generated_prover_stage8_source_stage(plan.source_stage.as_str()), + source_claim: generated_prover_stage8::Stage8SourceClaim::new(leak_str( + &plan.source_claim, + )), + oracle: leak_str(&plan.oracle), + domain: leak_str(&plan.domain), + point_arity: plan.point_arity, + claim_kind: generated_prover_stage8_claim_kind(plan.claim_kind.as_str()), + }) + .collect(), + ); + let opening_claims = leak_slice( + program + .opening_claims + .iter() + .map(|plan| generated_prover_stage8::Stage8OpeningClaimPlan { + symbol: generated_prover_stage8::Stage8OpeningClaimSymbol::new(leak_str( + &plan.symbol, + )), + oracle: leak_str(&plan.oracle), + family: leak_str(&plan.family), + domain: leak_str(&plan.domain), + point_arity: plan.point_arity, + point_source: generated_prover_stage8::Stage8OpeningInputSymbol::new(leak_str( + &plan.point_source, + )), + eval_source: generated_prover_stage8::Stage8OpeningInputSymbol::new(leak_str( + &plan.eval_source, + )), + source_stage: generated_prover_stage8_source_stage(plan.source_stage.as_str()), + source_claim: generated_prover_stage8::Stage8SourceClaim::new(leak_str( + &plan.source_claim, + )), + }) + .collect(), + ); + let evaluation_point_source = *opening_inputs + .get(evaluation_point_source_index) + .expect("stage8 evaluation point source exists"); + let ordered_claims = leak_slice( + ordered_claim_indices + .iter() + .map(|index| { + *opening_claims + .get(*index) + .expect("stage8 opening batch claim exists") + }) + .collect(), + ); + let opening_batch = program + .opening_batches + .first() + .expect("stage8 opening batch exists"); + let pcs_proof = program.pcs_proofs.first().expect("stage8 PCS proof exists"); + Box::leak(Box::new( + generated_prover_stage8::Stage8EvaluationProgramPlan { + role: role_name(&program.role), + function: leak_str(&program.function), + params: generated_prover_stage8::Stage8Params { + field: leak_str(&program.params.field), + pcs: leak_str(&program.params.pcs), + transcript: leak_str(&program.params.transcript), + }, + evaluation_point_source, + opening_inputs, + opening_claims, + opening_batch: generated_prover_stage8::Stage8OpeningBatchPlan { + symbol: generated_prover_stage8::Stage8OpeningBatchSymbol::new(leak_str( + &opening_batch.symbol, + )), + proof_slot: leak_str(&opening_batch.proof_slot), + policy: leak_str(&opening_batch.policy), + count: opening_batch.count, + ordered_claims, + }, + pcs_proof: generated_prover_stage8::Stage8PcsProofPlan { + symbol: leak_str(&pcs_proof.symbol), + mode: generated_prover_stage8_pcs_proof_mode(pcs_proof.mode.as_str()), + pcs: leak_str(&pcs_proof.pcs), + proof_slot: leak_str(&pcs_proof.proof_slot), + transcript_label: leak_str(&pcs_proof.transcript_label), + batch: generated_prover_stage8::Stage8OpeningBatchSymbol::new(leak_str( + &pcs_proof.batch, + )), + }, + }, + )) +} + +#[expect( + clippy::expect_used, + reason = "Stage 8 adapters consume compiler-validated plans and fail fast if required generated plan rows are missing" +)] +pub(crate) fn leak_generated_stage8_verifier_program( + program: &CompilerStage8CpuProgram, +) -> &'static generated_stage8::Stage8EvaluationProgramPlan { + let evaluation_point_source_index = stage8_evaluation_point_source_index(program); + let ordered_claim_indices = stage8_ordered_claim_indices(program); + let opening_inputs = leak_slice( + program + .opening_inputs + .iter() + .map(|plan| generated_stage8::Stage8OpeningInputPlan { + symbol: generated_stage8::Stage8OpeningInputSymbol::new(leak_str(&plan.symbol)), + source_stage: generated_stage8_source_stage(plan.source_stage.as_str()), + source_claim: generated_stage8::Stage8SourceClaim::new(leak_str( + &plan.source_claim, + )), + oracle: leak_str(&plan.oracle), + domain: leak_str(&plan.domain), + point_arity: plan.point_arity, + claim_kind: generated_stage8_claim_kind(plan.claim_kind.as_str()), + }) + .collect(), + ); + let opening_claims = leak_slice( + program + .opening_claims + .iter() + .map(|plan| generated_stage8::Stage8OpeningClaimPlan { + symbol: generated_stage8::Stage8OpeningClaimSymbol::new(leak_str(&plan.symbol)), + oracle: leak_str(&plan.oracle), + family: leak_str(&plan.family), + domain: leak_str(&plan.domain), + point_arity: plan.point_arity, + point_source: generated_stage8::Stage8OpeningInputSymbol::new(leak_str( + &plan.point_source, + )), + eval_source: generated_stage8::Stage8OpeningInputSymbol::new(leak_str( + &plan.eval_source, + )), + source_stage: generated_stage8_source_stage(plan.source_stage.as_str()), + source_claim: generated_stage8::Stage8SourceClaim::new(leak_str( + &plan.source_claim, + )), + }) + .collect(), + ); + let evaluation_point_source = *opening_inputs + .get(evaluation_point_source_index) + .expect("stage8 evaluation point source exists"); + let ordered_claims = leak_slice( + ordered_claim_indices + .iter() + .map(|index| { + *opening_claims + .get(*index) + .expect("stage8 opening batch claim exists") + }) + .collect(), + ); + let opening_batch = program + .opening_batches + .first() + .expect("stage8 opening batch exists"); + let pcs_proof = program.pcs_proofs.first().expect("stage8 PCS proof exists"); + Box::leak(Box::new(generated_stage8::Stage8EvaluationProgramPlan { + role: role_name(&program.role), + function: leak_str(&program.function), + params: generated_stage8::Stage8Params { + field: leak_str(&program.params.field), + pcs: leak_str(&program.params.pcs), + transcript: leak_str(&program.params.transcript), + }, + evaluation_point_source, + opening_inputs, + opening_claims, + opening_batch: generated_stage8::Stage8OpeningBatchPlan { + symbol: generated_stage8::Stage8OpeningBatchSymbol::new(leak_str( + &opening_batch.symbol, + )), + proof_slot: leak_str(&opening_batch.proof_slot), + policy: leak_str(&opening_batch.policy), + count: opening_batch.count, + ordered_claims, + }, + pcs_proof: generated_stage8::Stage8PcsProofPlan { + symbol: leak_str(&pcs_proof.symbol), + mode: generated_stage8_pcs_proof_mode(pcs_proof.mode.as_str()), + pcs: leak_str(&pcs_proof.pcs), + proof_slot: leak_str(&pcs_proof.proof_slot), + transcript_label: leak_str(&pcs_proof.transcript_label), + batch: generated_stage8::Stage8OpeningBatchSymbol::new(leak_str(&pcs_proof.batch)), + }, + })) +} fn role_name(role: &Role) -> &'static str { match role { From d7246ed3f55104fbf627372915a3331defb64d0e Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 19:46:03 -0600 Subject: [PATCH 012/171] refactor(bolt): remove stage6 stage7 table macros --- .../src/protocols/jolt/emit/rust/stage6.rs | 8 +- .../src/protocols/jolt/emit/rust/stage7.rs | 8 +- crates/bolt/tests/verifier_cleanup.rs | 20 +++ crates/jolt-prover/src/stages/stage6.rs | 48 +++-- crates/jolt-prover/src/stages/stage7.rs | 26 ++- crates/jolt-verifier/src/stages/stage6.rs | 166 +++++++++--------- crates/jolt-verifier/src/stages/stage7.rs | 120 ++++++------- 7 files changed, 202 insertions(+), 194 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index f001794bea..e5993fb161 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1535,7 +1535,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); .iter() .map(|expr| { Ok(format!( - "stage6_field_expr!({}, {}, {})", + "stage6_field_expr({}, {}, {})", rust_str(&expr.symbol), super::plan_tokens::role_field_expr_kind_expr( "Stage6", @@ -1552,7 +1552,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); .collect::, EmitError>>()? .join("\n"); return Ok(format!( - "macro_rules! stage6_field_expr {{\n ($symbol:literal, $kind:expr, $operands:expr) => {{\n Stage6FieldExprPlan {{ symbol: $symbol, kind: $kind, operands: $operands }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[\n{rows}\n];\n" + "const fn stage6_field_expr(symbol: &'static str, kind: Stage6FieldExprKind, operands: &'static [&'static str]) -> Stage6FieldExprPlan {{\n Stage6FieldExprPlan {{ symbol, kind, operands }}\n}}\n\n#[rustfmt::skip]\npub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[\n{rows}\n];\n" )); } @@ -1863,7 +1863,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); .iter() .map(|eval| { format!( - "stage6_sumcheck_eval!({}, {}, {}, {}, {})", + "stage6_sumcheck_eval({}, {}, {}, {}, {})", rust_str(&eval.symbol), rust_str(&eval.source), rust_str(&eval.name), @@ -1878,7 +1878,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); .collect::>() .join("\n"); format!( - "macro_rules! stage6_sumcheck_eval {{\n ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => {{\n Stage6SumcheckEvalPlan {{ symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE6_SUMCHECK_EVALS: &[Stage6SumcheckEvalPlan] = &[\n{rows}\n];\n\n" + "const fn stage6_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage6SumcheckEvalPlan {{\n Stage6SumcheckEvalPlan {{ symbol, source, name, index, oracle }}\n}}\n\n#[rustfmt::skip]\npub const STAGE6_SUMCHECK_EVALS: &[Stage6SumcheckEvalPlan] = &[\n{rows}\n];\n\n" ) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 0266cf7e57..2b6d774aa4 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1431,7 +1431,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); .iter() .map(|expr| { Ok(format!( - "stage7_field_expr!({}, {}, {})", + "stage7_field_expr({}, {}, {})", rust_str(&expr.symbol), super::plan_tokens::role_field_expr_kind_expr( "Stage7", @@ -1448,7 +1448,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); .collect::, EmitError>>()? .join("\n"); return Ok(format!( - "macro_rules! stage7_field_expr {{\n ($symbol:literal, $kind:expr, $operands:expr) => {{\n Stage7FieldExprPlan {{ symbol: $symbol, kind: $kind, operands: $operands }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[\n{rows}\n];\n" + "const fn stage7_field_expr(symbol: &'static str, kind: Stage7FieldExprKind, operands: &'static [&'static str]) -> Stage7FieldExprPlan {{\n Stage7FieldExprPlan {{ symbol, kind, operands }}\n}}\n\n#[rustfmt::skip]\npub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[\n{rows}\n];\n" )); } @@ -1759,7 +1759,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); .iter() .map(|eval| { format!( - "stage7_sumcheck_eval!({}, {}, {}, {}, {})", + "stage7_sumcheck_eval({}, {}, {}, {}, {})", rust_str(&eval.symbol), rust_str(&eval.source), rust_str(&eval.name), @@ -1774,7 +1774,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); .collect::>() .join("\n"); format!( - "macro_rules! stage7_sumcheck_eval {{\n ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => {{\n Stage7SumcheckEvalPlan {{ symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle }}\n }};\n}}\n\n#[rustfmt::skip]\npub const STAGE7_SUMCHECK_EVALS: &[Stage7SumcheckEvalPlan] = &[\n{rows}\n];\n\n" + "const fn stage7_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage7SumcheckEvalPlan {{\n Stage7SumcheckEvalPlan {{ symbol, source, name, index, oracle }}\n}}\n\n#[rustfmt::skip]\npub const STAGE7_SUMCHECK_EVALS: &[Stage7SumcheckEvalPlan] = &[\n{rows}\n];\n\n" ) } diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 16a953f491..9b5a5d2e6d 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -21,6 +21,7 @@ const FIELD_EXPR_OPERAND_CONSTANT_BASELINE_CEILING: usize = 0; const BATCH_OPERAND_STRING_SITE_BASELINE_CEILING: usize = 0; const CLAIM_INPUT_OPENING_STRING_SITE_BASELINE_CEILING: usize = 0; const POINT_CONCAT_INPUT_STRING_SITE_BASELINE_CEILING: usize = 0; +const STAGE_LOCAL_MACRO_RULES_BASELINE_CEILING: usize = 0; const STAGE_HELPER_FUNCTION_BASELINE_CEILING: usize = 38; const RELATION_STRING_SITE_BASELINE_CEILING: usize = 0; @@ -120,6 +121,7 @@ struct VerifierCleanupMetrics { batch_operand_string_sites: usize, claim_input_opening_string_sites: usize, point_concat_input_string_sites: usize, + stage_local_macro_rules: usize, stage_local_helper_functions: usize, relation_string_sites: usize, } @@ -144,6 +146,7 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { batch_operand_string_sites: {batch_operand_string_sites} (baseline ceiling <= {batch_operand_baseline})\n\ claim_input_opening_string_sites: {claim_input_opening_string_sites} (baseline ceiling <= {claim_input_opening_baseline})\n\ point_concat_input_string_sites: {point_concat_input_string_sites} (baseline ceiling <= {point_concat_input_baseline})\n\ + stage_local_macro_rules: {stage_local_macro_rules} (baseline ceiling <= {macro_rules_baseline})\n\ stage_local_helper_functions: {helper_functions} (baseline ceiling <= {helper_baseline})\n\ relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})", generated_surface_loc = metrics.generated_surface_loc, @@ -170,6 +173,8 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { claim_input_opening_baseline = CLAIM_INPUT_OPENING_STRING_SITE_BASELINE_CEILING, point_concat_input_string_sites = metrics.point_concat_input_string_sites, point_concat_input_baseline = POINT_CONCAT_INPUT_STRING_SITE_BASELINE_CEILING, + stage_local_macro_rules = metrics.stage_local_macro_rules, + macro_rules_baseline = STAGE_LOCAL_MACRO_RULES_BASELINE_CEILING, helper_functions = metrics.stage_local_helper_functions, helper_baseline = STAGE_HELPER_FUNCTION_BASELINE_CEILING, relation_sites = metrics.relation_string_sites, @@ -231,6 +236,11 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { "point-concat input string sites grew to {}; prefer structured point input slices", metrics.point_concat_input_string_sites ); + assert!( + metrics.stage_local_macro_rules <= STAGE_LOCAL_MACRO_RULES_BASELINE_CEILING, + "stage-local macro_rules sites grew to {}; prefer named constructors or shared runtime helpers", + metrics.stage_local_macro_rules + ); assert!( metrics.stage_local_helper_functions <= STAGE_HELPER_FUNCTION_BASELINE_CEILING, "stage-local helper function count grew to {}; factor verifier mechanics into shared runtime", @@ -454,6 +464,9 @@ fn verifier_cleanup_metrics(verifier_src: &Path) -> VerifierCleanupMetrics { if relative == Path::new("stages/stage6.rs") || relative == Path::new("stages/stage7.rs") { metrics.stage6_stage7_loc += line_count; } + if relative.to_string_lossy().starts_with("stages/stage") { + metrics.stage_local_macro_rules += count_stage_local_macro_rules(&source); + } if relative.starts_with("stages") { metrics.stage_local_generic_plan_structs += count_stage_local_generic_plan_structs(&source); @@ -526,6 +539,13 @@ fn count_point_concat_input_string_sites(source: &str) -> usize { .count() } +fn count_stage_local_macro_rules(source: &str) -> usize { + source + .lines() + .filter(|line| line.trim_start().starts_with("macro_rules!")) + .count() +} + fn count_stage_local_helper_functions(source: &str) -> usize { const HELPER_PREFIXES: &[&str] = &[ "fn evaluate_stage", diff --git a/crates/jolt-prover/src/stages/stage6.rs b/crates/jolt-prover/src/stages/stage6.rs index cdb6e9601f..37c8c578a3 100644 --- a/crates/jolt-prover/src/stages/stage6.rs +++ b/crates/jolt-prover/src/stages/stage6.rs @@ -1901,35 +1901,33 @@ pub const STAGE6_SUMCHECK_INSTANCE_RESULTS: &[Stage6SumcheckInstanceResultPlan] Stage6SumcheckInstanceResultPlan { symbol: "stage6.inc_claim_reduction.instance", source: "stage6.sumcheck", claim: "stage6.inc_claim_reduction.input", relation: "jolt.stage6.inc_claim_reduction", index: 5, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 2 }, ]; -macro_rules! stage6_sumcheck_eval { - ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => { - Stage6SumcheckEvalPlan { symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle } - }; +const fn stage6_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage6SumcheckEvalPlan { + Stage6SumcheckEvalPlan { symbol, source, name, index, oracle } } #[rustfmt::skip] pub const STAGE6_SUMCHECK_EVALS: &[Stage6SumcheckEvalPlan] = &[ - stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_0", 0, "BytecodeRa_0"), stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_1", 1, "BytecodeRa_1"), stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_2", 2, "BytecodeRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_0", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_0", 0, "InstructionRa_0"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_1", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_2", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_3", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_4", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_4", 4, "InstructionRa_4"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_5", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_6", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_7", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_8", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_8", 8, "InstructionRa_8"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_9", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_10", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_11", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_12", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_12", 12, "InstructionRa_12"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_13", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_14", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_15", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_16", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_16", 16, "InstructionRa_16"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_17", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_18", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_19", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_20", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_20", 20, "InstructionRa_20"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_21", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_22", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_23", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_24", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_24", 24, "InstructionRa_24"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_25", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_26", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_27", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_28", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_28", 28, "InstructionRa_28"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_29", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_30", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_31", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_0", 32, "BytecodeRa_0"), - stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_0", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_0", 35, "RamRa_0"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_1", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_1", 36, "RamRa_1"), - stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_2", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_2", 37, "RamRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_3", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_3", 38, "RamRa_3"), stage6_sumcheck_eval!("stage6.hamming_booleanity.eval.HammingWeight", "stage6.sumcheck", "stage6.hamming_booleanity.eval.HammingWeight", 0, "HammingWeight"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_0", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_0", 0, "RamRa_0"), - stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_1", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_1", 1, "RamRa_1"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_2", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_2", 2, "RamRa_2"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_3", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_3", 3, "RamRa_3"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_0", 0, "InstructionRa_0"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_4", 4, "InstructionRa_4"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_8", 8, "InstructionRa_8"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_12", 12, "InstructionRa_12"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_16", 16, "InstructionRa_16"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_20", 20, "InstructionRa_20"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_24", 24, "InstructionRa_24"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_28", 28, "InstructionRa_28"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval!("stage6.inc_claim_reduction.eval.RamInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RamInc", 0, "RamInc"), - stage6_sumcheck_eval!("stage6.inc_claim_reduction.eval.RdInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RdInc", 1, "RdInc"), + stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_0", 0, "BytecodeRa_0"), stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_1", 1, "BytecodeRa_1"), stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_2", 2, "BytecodeRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_0", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_0", 0, "InstructionRa_0"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_1", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_2", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_3", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_4", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_4", 4, "InstructionRa_4"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_5", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_6", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_7", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_8", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_8", 8, "InstructionRa_8"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_9", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_10", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_11", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_12", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_12", 12, "InstructionRa_12"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_13", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_14", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_15", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_16", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_16", 16, "InstructionRa_16"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_17", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_18", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_19", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_20", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_20", 20, "InstructionRa_20"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_21", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_22", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_23", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_24", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_24", 24, "InstructionRa_24"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_25", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_26", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_27", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_28", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_28", 28, "InstructionRa_28"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_29", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_30", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_31", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_0", 32, "BytecodeRa_0"), + stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_0", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_0", 35, "RamRa_0"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_1", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_1", 36, "RamRa_1"), + stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_2", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_2", 37, "RamRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_3", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_3", 38, "RamRa_3"), stage6_sumcheck_eval("stage6.hamming_booleanity.eval.HammingWeight", "stage6.sumcheck", "stage6.hamming_booleanity.eval.HammingWeight", 0, "HammingWeight"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_0", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_0", 0, "RamRa_0"), + stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_1", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_1", 1, "RamRa_1"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_2", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_2", 2, "RamRa_2"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_3", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_3", 3, "RamRa_3"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_0", 0, "InstructionRa_0"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_4", 4, "InstructionRa_4"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_8", 8, "InstructionRa_8"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_12", 12, "InstructionRa_12"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_16", 16, "InstructionRa_16"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_20", 20, "InstructionRa_20"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_24", 24, "InstructionRa_24"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_28", 28, "InstructionRa_28"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval("stage6.inc_claim_reduction.eval.RamInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RamInc", 0, "RamInc"), + stage6_sumcheck_eval("stage6.inc_claim_reduction.eval.RdInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RdInc", 1, "RdInc"), ]; pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[ diff --git a/crates/jolt-prover/src/stages/stage7.rs b/crates/jolt-prover/src/stages/stage7.rs index fb8ecbebf5..5f497a8d85 100644 --- a/crates/jolt-prover/src/stages/stage7.rs +++ b/crates/jolt-prover/src/stages/stage7.rs @@ -1726,24 +1726,22 @@ pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] Stage7SumcheckInstanceResultPlan { symbol: "stage7.hamming_weight_claim_reduction.instance", source: "stage7.sumcheck", claim: "stage7.hamming_weight_claim_reduction.input", relation: "jolt.stage7.hamming_weight_claim_reduction", index: 0, point_arity: 4, num_rounds: 4, round_offset: 0, point_order: "reverse", degree: 2 }, ]; -macro_rules! stage7_sumcheck_eval { - ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => { - Stage7SumcheckEvalPlan { symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle } - }; +const fn stage7_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage7SumcheckEvalPlan { + Stage7SumcheckEvalPlan { symbol, source, name, index, oracle } } #[rustfmt::skip] pub const STAGE7_SUMCHECK_EVALS: &[Stage7SumcheckEvalPlan] = &[ - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", 0, "InstructionRa_0"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", 1, "InstructionRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", 2, "InstructionRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", 3, "InstructionRa_3"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", 4, "InstructionRa_4"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", 5, "InstructionRa_5"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", 6, "InstructionRa_6"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", 7, "InstructionRa_7"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", 8, "InstructionRa_8"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", 9, "InstructionRa_9"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", 10, "InstructionRa_10"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", 11, "InstructionRa_11"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", 12, "InstructionRa_12"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", 13, "InstructionRa_13"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", 14, "InstructionRa_14"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", 15, "InstructionRa_15"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", 16, "InstructionRa_16"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", 17, "InstructionRa_17"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", 18, "InstructionRa_18"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", 19, "InstructionRa_19"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", 20, "InstructionRa_20"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", 21, "InstructionRa_21"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", 22, "InstructionRa_22"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", 23, "InstructionRa_23"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", 24, "InstructionRa_24"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", 25, "InstructionRa_25"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", 26, "InstructionRa_26"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", 27, "InstructionRa_27"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", 28, "InstructionRa_28"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", 29, "InstructionRa_29"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", 30, "InstructionRa_30"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", 31, "InstructionRa_31"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", 32, "BytecodeRa_0"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", 35, "RamRa_0"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", 36, "RamRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", 37, "RamRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", 38, "RamRa_3"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", 0, "InstructionRa_0"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", 1, "InstructionRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", 2, "InstructionRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", 3, "InstructionRa_3"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", 4, "InstructionRa_4"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", 5, "InstructionRa_5"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", 6, "InstructionRa_6"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", 7, "InstructionRa_7"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", 8, "InstructionRa_8"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", 9, "InstructionRa_9"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", 10, "InstructionRa_10"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", 11, "InstructionRa_11"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", 12, "InstructionRa_12"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", 13, "InstructionRa_13"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", 14, "InstructionRa_14"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", 15, "InstructionRa_15"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", 16, "InstructionRa_16"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", 17, "InstructionRa_17"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", 18, "InstructionRa_18"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", 19, "InstructionRa_19"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", 20, "InstructionRa_20"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", 21, "InstructionRa_21"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", 22, "InstructionRa_22"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", 23, "InstructionRa_23"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", 24, "InstructionRa_24"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", 25, "InstructionRa_25"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", 26, "InstructionRa_26"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", 27, "InstructionRa_27"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", 28, "InstructionRa_28"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", 29, "InstructionRa_29"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", 30, "InstructionRa_30"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", 31, "InstructionRa_31"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", 32, "BytecodeRa_0"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", 35, "RamRa_0"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", 36, "RamRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", 37, "RamRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", 38, "RamRa_3"), ]; pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[ diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index b352d0a995..30fca1ee92 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -281,70 +281,68 @@ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ Stage6FieldConstantPlan { symbol: "stage6.zero", field: "bn254_fr", value: 0 }, ]; -macro_rules! stage6_field_expr { - ($symbol:literal, $kind:expr, $operands:expr) => { - Stage6FieldExprPlan { symbol: $symbol, kind: $kind, operands: $operands } - }; +const fn stage6_field_expr(symbol: &'static str, kind: Stage6FieldExprKind, operands: &'static [&'static str]) -> Stage6FieldExprPlan { + Stage6FieldExprPlan { symbol, kind, operands } } #[rustfmt::skip] pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ - stage6_field_expr!("stage6.booleanity.gamma_sq_0", Stage6FieldExprKind::Pow(0), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_1", Stage6FieldExprKind::Pow(2), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_2", Stage6FieldExprKind::Pow(4), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_3", Stage6FieldExprKind::Pow(6), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_4", Stage6FieldExprKind::Pow(8), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_5", Stage6FieldExprKind::Pow(10), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_6", Stage6FieldExprKind::Pow(12), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_7", Stage6FieldExprKind::Pow(14), &["stage6.booleanity.gamma"]), - stage6_field_expr!("stage6.booleanity.gamma_sq_8", Stage6FieldExprKind::Pow(16), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_9", Stage6FieldExprKind::Pow(18), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_10", Stage6FieldExprKind::Pow(20), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_11", Stage6FieldExprKind::Pow(22), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_12", Stage6FieldExprKind::Pow(24), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_13", Stage6FieldExprKind::Pow(26), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_14", Stage6FieldExprKind::Pow(28), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_15", Stage6FieldExprKind::Pow(30), &["stage6.booleanity.gamma"]), - stage6_field_expr!("stage6.booleanity.gamma_sq_16", Stage6FieldExprKind::Pow(32), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_17", Stage6FieldExprKind::Pow(34), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_18", Stage6FieldExprKind::Pow(36), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_19", Stage6FieldExprKind::Pow(38), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_20", Stage6FieldExprKind::Pow(40), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_21", Stage6FieldExprKind::Pow(42), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_22", Stage6FieldExprKind::Pow(44), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_23", Stage6FieldExprKind::Pow(46), &["stage6.booleanity.gamma"]), - stage6_field_expr!("stage6.booleanity.gamma_sq_24", Stage6FieldExprKind::Pow(48), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_25", Stage6FieldExprKind::Pow(50), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_26", Stage6FieldExprKind::Pow(52), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_27", Stage6FieldExprKind::Pow(54), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_28", Stage6FieldExprKind::Pow(56), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_29", Stage6FieldExprKind::Pow(58), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_30", Stage6FieldExprKind::Pow(60), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_31", Stage6FieldExprKind::Pow(62), &["stage6.booleanity.gamma"]), - stage6_field_expr!("stage6.booleanity.gamma_sq_32", Stage6FieldExprKind::Pow(64), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_33", Stage6FieldExprKind::Pow(66), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_34", Stage6FieldExprKind::Pow(68), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_35", Stage6FieldExprKind::Pow(70), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_36", Stage6FieldExprKind::Pow(72), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_37", Stage6FieldExprKind::Pow(74), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_sq_38", Stage6FieldExprKind::Pow(76), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_0", Stage6FieldExprKind::Pow(0), &["stage6.booleanity.gamma"]), - stage6_field_expr!("stage6.booleanity.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_8", Stage6FieldExprKind::Pow(8), &["stage6.booleanity.gamma"]), - stage6_field_expr!("stage6.booleanity.gamma_pow_9", Stage6FieldExprKind::Pow(9), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_10", Stage6FieldExprKind::Pow(10), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_11", Stage6FieldExprKind::Pow(11), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_12", Stage6FieldExprKind::Pow(12), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_13", Stage6FieldExprKind::Pow(13), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_14", Stage6FieldExprKind::Pow(14), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_15", Stage6FieldExprKind::Pow(15), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_16", Stage6FieldExprKind::Pow(16), &["stage6.booleanity.gamma"]), - stage6_field_expr!("stage6.booleanity.gamma_pow_17", Stage6FieldExprKind::Pow(17), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_18", Stage6FieldExprKind::Pow(18), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_19", Stage6FieldExprKind::Pow(19), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_20", Stage6FieldExprKind::Pow(20), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_21", Stage6FieldExprKind::Pow(21), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_22", Stage6FieldExprKind::Pow(22), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_23", Stage6FieldExprKind::Pow(23), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_24", Stage6FieldExprKind::Pow(24), &["stage6.booleanity.gamma"]), - stage6_field_expr!("stage6.booleanity.gamma_pow_25", Stage6FieldExprKind::Pow(25), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_26", Stage6FieldExprKind::Pow(26), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_27", Stage6FieldExprKind::Pow(27), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_28", Stage6FieldExprKind::Pow(28), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_29", Stage6FieldExprKind::Pow(29), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_30", Stage6FieldExprKind::Pow(30), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_31", Stage6FieldExprKind::Pow(31), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_32", Stage6FieldExprKind::Pow(32), &["stage6.booleanity.gamma"]), - stage6_field_expr!("stage6.booleanity.gamma_pow_33", Stage6FieldExprKind::Pow(33), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_34", Stage6FieldExprKind::Pow(34), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_35", Stage6FieldExprKind::Pow(35), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_36", Stage6FieldExprKind::Pow(36), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_37", Stage6FieldExprKind::Pow(37), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.booleanity.gamma_pow_38", Stage6FieldExprKind::Pow(38), &["stage6.booleanity.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term1.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", "stage6.input.stage1.Imm"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term2.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", "stage6.input.stage1.OpFlagAddOperands"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term3.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", "stage6.input.stage1.OpFlagSubtractOperands"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term4.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", "stage6.input.stage1.OpFlagMultiplyOperands"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term5.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", "stage6.input.stage1.OpFlagLoad"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term6.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", "stage6.input.stage1.OpFlagStore"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term7.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", "stage6.input.stage1.OpFlagJump"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term8.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", "stage6.input.stage1.OpFlagWriteLookupOutputToRD"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term9.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", "stage6.input.stage1.OpFlagVirtualInstruction"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term10.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", "stage6.input.stage1.OpFlagAssert"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term11.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term12.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", "stage6.input.stage1.OpFlagAdvice"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term13.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", "stage6.input.stage1.OpFlagIsCompressed"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term14.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", "stage6.input.stage1.OpFlagIsFirstInSequence"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term15.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", "stage6.input.stage1.OpFlagIsLastInSequence"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term16.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term16.gamma_pow", "stage6.input.stage2.OpFlagJump"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", "stage6.input.stage2.InstructionFlagBranch"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term17.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.gamma_pow", "stage6.bytecode_read_raf.claim.term17.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", "stage6.input.stage2.OpFlagWriteLookupOutputToRD"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term18.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.gamma_pow", "stage6.bytecode_read_raf.claim.term18.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", "stage6.input.stage2.OpFlagVirtualInstruction"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term19.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.gamma_pow", "stage6.bytecode_read_raf.claim.term19.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term20.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term20.gamma_pow", "stage6.input.stage3.instruction_input.Imm"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", "stage6.input.stage3.spartan_shift.UnexpandedPC"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term21.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.gamma_pow", "stage6.bytecode_read_raf.claim.term21.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term22.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.gamma_pow", "stage6.bytecode_read_raf.claim.term22.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term23.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.gamma_pow", "stage6.bytecode_read_raf.claim.term23.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term24.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.gamma_pow", "stage6.bytecode_read_raf.claim.term24.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term25.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.gamma_pow", "stage6.bytecode_read_raf.claim.term25.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term26.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.gamma_pow", "stage6.bytecode_read_raf.claim.term26.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term27.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.gamma_pow", "stage6.bytecode_read_raf.claim.term27.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term28.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.gamma_pow", "stage6.bytecode_read_raf.claim.term28.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term29.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term29.gamma_pow", "stage6.input.stage4.RdWa"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", "stage6.input.stage4.Rs1Ra"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term30.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.gamma_pow", "stage6.bytecode_read_raf.claim.term30.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", "stage6.input.stage4.Rs2Ra"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term31.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.gamma_pow", "stage6.bytecode_read_raf.claim.term31.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term32.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term32.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdWa"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", "stage6.input.stage5.InstructionRafFlag"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term33.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.gamma_pow", "stage6.bytecode_read_raf.claim.term33.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_0"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term34.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.gamma_pow", "stage6.bytecode_read_raf.claim.term34.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_1"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term35.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.gamma_pow", "stage6.bytecode_read_raf.claim.term35.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_2"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term36.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.gamma_pow", "stage6.bytecode_read_raf.claim.term36.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_3"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term37.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.gamma_pow", "stage6.bytecode_read_raf.claim.term37.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_4"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term38.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.gamma_pow", "stage6.bytecode_read_raf.claim.term38.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_5"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term39.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.gamma_pow", "stage6.bytecode_read_raf.claim.term39.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_6"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term40.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.gamma_pow", "stage6.bytecode_read_raf.claim.term40.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_7"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term41.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.gamma_pow", "stage6.bytecode_read_raf.claim.term41.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_8"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term42.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.gamma_pow", "stage6.bytecode_read_raf.claim.term42.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_9"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term43.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.gamma_pow", "stage6.bytecode_read_raf.claim.term43.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_10"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term44.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.gamma_pow", "stage6.bytecode_read_raf.claim.term44.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_11"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term45.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.gamma_pow", "stage6.bytecode_read_raf.claim.term45.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_12"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term46.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.gamma_pow", "stage6.bytecode_read_raf.claim.term46.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_13"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term47.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.gamma_pow", "stage6.bytecode_read_raf.claim.term47.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", Stage6FieldExprKind::Pow(16), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_14"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term48.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.gamma_pow", "stage6.bytecode_read_raf.claim.term48.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", Stage6FieldExprKind::Pow(17), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_15"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term49.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.gamma_pow", "stage6.bytecode_read_raf.claim.term49.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", Stage6FieldExprKind::Pow(18), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_16"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term50.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.gamma_pow", "stage6.bytecode_read_raf.claim.term50.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", Stage6FieldExprKind::Pow(19), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_17"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term51.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.gamma_pow", "stage6.bytecode_read_raf.claim.term51.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", Stage6FieldExprKind::Pow(20), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_18"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term52.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.gamma_pow", "stage6.bytecode_read_raf.claim.term52.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", Stage6FieldExprKind::Pow(21), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_19"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term53.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.gamma_pow", "stage6.bytecode_read_raf.claim.term53.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", Stage6FieldExprKind::Pow(22), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_20"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term54.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.gamma_pow", "stage6.bytecode_read_raf.claim.term54.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", Stage6FieldExprKind::Pow(23), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_21"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term55.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.gamma_pow", "stage6.bytecode_read_raf.claim.term55.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", Stage6FieldExprKind::Pow(24), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_22"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term56.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.gamma_pow", "stage6.bytecode_read_raf.claim.term56.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", Stage6FieldExprKind::Pow(25), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_23"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term57.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.gamma_pow", "stage6.bytecode_read_raf.claim.term57.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", Stage6FieldExprKind::Pow(26), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_24"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term58.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.gamma_pow", "stage6.bytecode_read_raf.claim.term58.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", Stage6FieldExprKind::Pow(27), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_25"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term59.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.gamma_pow", "stage6.bytecode_read_raf.claim.term59.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", Stage6FieldExprKind::Pow(28), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_26"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term60.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.gamma_pow", "stage6.bytecode_read_raf.claim.term60.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", Stage6FieldExprKind::Pow(29), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_27"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term61.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.gamma_pow", "stage6.bytecode_read_raf.claim.term61.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", Stage6FieldExprKind::Pow(30), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_28"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term62.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.gamma_pow", "stage6.bytecode_read_raf.claim.term62.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", Stage6FieldExprKind::Pow(31), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_29"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term63.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.gamma_pow", "stage6.bytecode_read_raf.claim.term63.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", Stage6FieldExprKind::Pow(32), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_30"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term64.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.gamma_pow", "stage6.bytecode_read_raf.claim.term64.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", Stage6FieldExprKind::Pow(33), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_31"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term65.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.gamma_pow", "stage6.bytecode_read_raf.claim.term65.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", Stage6FieldExprKind::Pow(34), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_32"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term66.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.gamma_pow", "stage6.bytecode_read_raf.claim.term66.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", Stage6FieldExprKind::Pow(35), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_33"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term67.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.gamma_pow", "stage6.bytecode_read_raf.claim.term67.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", Stage6FieldExprKind::Pow(36), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_34"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term68.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.gamma_pow", "stage6.bytecode_read_raf.claim.term68.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", Stage6FieldExprKind::Pow(37), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_35"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term69.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.gamma_pow", "stage6.bytecode_read_raf.claim.term69.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", Stage6FieldExprKind::Pow(38), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_36"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term70.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.gamma_pow", "stage6.bytecode_read_raf.claim.term70.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", Stage6FieldExprKind::Pow(39), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_37"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term71.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.gamma_pow", "stage6.bytecode_read_raf.claim.term71.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", Stage6FieldExprKind::Pow(40), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_38"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term72.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.gamma_pow", "stage6.bytecode_read_raf.claim.term72.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", Stage6FieldExprKind::Pow(41), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_39"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term73.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.gamma_pow", "stage6.bytecode_read_raf.claim.term73.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", Stage6FieldExprKind::Pow(42), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_40"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term74.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.gamma_pow", "stage6.bytecode_read_raf.claim.term74.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term75.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term75.gamma_pow", "stage6.input.stage1.PC"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.term76.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term76.gamma_pow", "stage6.input.stage3.spartan_shift.PC"]), stage6_field_expr!("stage6.bytecode_read_raf.claim.entry_constant", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage1.UnexpandedPC", "stage6.bytecode_read_raf.claim.term1.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial0", "stage6.bytecode_read_raf.claim.term2.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial1", "stage6.bytecode_read_raf.claim.term3.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial2", "stage6.bytecode_read_raf.claim.term4.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial3", "stage6.bytecode_read_raf.claim.term5.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial4", "stage6.bytecode_read_raf.claim.term6.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial5", "stage6.bytecode_read_raf.claim.term7.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial7", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial6", "stage6.bytecode_read_raf.claim.term8.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial8", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial7", "stage6.bytecode_read_raf.claim.term9.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial9", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial8", "stage6.bytecode_read_raf.claim.term10.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial10", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial9", "stage6.bytecode_read_raf.claim.term11.stage_gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial11", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial10", "stage6.bytecode_read_raf.claim.term12.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial12", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial11", "stage6.bytecode_read_raf.claim.term13.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial13", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial12", "stage6.bytecode_read_raf.claim.term14.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial14", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial13", "stage6.bytecode_read_raf.claim.term15.stage_gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial15", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial14", "stage6.bytecode_read_raf.claim.term16.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial16", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial15", "stage6.bytecode_read_raf.claim.term17.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial17", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial16", "stage6.bytecode_read_raf.claim.term18.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial18", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial17", "stage6.bytecode_read_raf.claim.term19.gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial19", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial18", "stage6.bytecode_read_raf.claim.term20.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial20", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial19", "stage6.bytecode_read_raf.claim.term21.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial21", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial20", "stage6.bytecode_read_raf.claim.term22.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial22", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial21", "stage6.bytecode_read_raf.claim.term23.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial23", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial22", "stage6.bytecode_read_raf.claim.term24.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial24", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial23", "stage6.bytecode_read_raf.claim.term25.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial25", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial24", "stage6.bytecode_read_raf.claim.term26.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial26", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial25", "stage6.bytecode_read_raf.claim.term27.gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial27", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial26", "stage6.bytecode_read_raf.claim.term28.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial28", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial27", "stage6.bytecode_read_raf.claim.term29.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial29", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial28", "stage6.bytecode_read_raf.claim.term30.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial30", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial29", "stage6.bytecode_read_raf.claim.term31.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial31", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial30", "stage6.bytecode_read_raf.claim.term32.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial32", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial31", "stage6.bytecode_read_raf.claim.term33.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial33", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial32", "stage6.bytecode_read_raf.claim.term34.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial34", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial33", "stage6.bytecode_read_raf.claim.term35.gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial35", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial34", "stage6.bytecode_read_raf.claim.term36.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial36", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial35", "stage6.bytecode_read_raf.claim.term37.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial37", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial36", "stage6.bytecode_read_raf.claim.term38.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial38", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial37", "stage6.bytecode_read_raf.claim.term39.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial39", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial38", "stage6.bytecode_read_raf.claim.term40.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial40", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial39", "stage6.bytecode_read_raf.claim.term41.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial41", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial40", "stage6.bytecode_read_raf.claim.term42.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial42", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial41", "stage6.bytecode_read_raf.claim.term43.gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial43", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial42", "stage6.bytecode_read_raf.claim.term44.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial44", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial43", "stage6.bytecode_read_raf.claim.term45.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial45", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial44", "stage6.bytecode_read_raf.claim.term46.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial46", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial45", "stage6.bytecode_read_raf.claim.term47.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial47", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial46", "stage6.bytecode_read_raf.claim.term48.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial48", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial47", "stage6.bytecode_read_raf.claim.term49.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial49", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial48", "stage6.bytecode_read_raf.claim.term50.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial50", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial49", "stage6.bytecode_read_raf.claim.term51.gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial51", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial50", "stage6.bytecode_read_raf.claim.term52.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial52", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial51", "stage6.bytecode_read_raf.claim.term53.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial53", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial52", "stage6.bytecode_read_raf.claim.term54.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial54", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial53", "stage6.bytecode_read_raf.claim.term55.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial55", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial54", "stage6.bytecode_read_raf.claim.term56.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial56", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial55", "stage6.bytecode_read_raf.claim.term57.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial57", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial56", "stage6.bytecode_read_raf.claim.term58.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial58", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial57", "stage6.bytecode_read_raf.claim.term59.gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial59", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial58", "stage6.bytecode_read_raf.claim.term60.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial60", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial59", "stage6.bytecode_read_raf.claim.term61.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial61", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial60", "stage6.bytecode_read_raf.claim.term62.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial62", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial61", "stage6.bytecode_read_raf.claim.term63.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial63", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial62", "stage6.bytecode_read_raf.claim.term64.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial64", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial63", "stage6.bytecode_read_raf.claim.term65.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial65", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial64", "stage6.bytecode_read_raf.claim.term66.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial66", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial65", "stage6.bytecode_read_raf.claim.term67.gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial67", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial66", "stage6.bytecode_read_raf.claim.term68.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial68", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial67", "stage6.bytecode_read_raf.claim.term69.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial69", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial68", "stage6.bytecode_read_raf.claim.term70.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial70", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial69", "stage6.bytecode_read_raf.claim.term71.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial71", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial70", "stage6.bytecode_read_raf.claim.term72.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial72", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial71", "stage6.bytecode_read_raf.claim.term73.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial73", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial72", "stage6.bytecode_read_raf.claim.term74.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial74", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial73", "stage6.bytecode_read_raf.claim.term75.gamma_term"]), - stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial75", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial74", "stage6.bytecode_read_raf.claim.term76.gamma_term"]), stage6_field_expr!("stage6.bytecode_read_raf.claim_expr.partial76", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial75", "stage6.bytecode_read_raf.claim.entry_constant"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term1.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term1.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_1"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term2.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term2.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_2"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term3.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_3"]), - stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), - stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr!("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), - stage6_field_expr!("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr!("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr!("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), + stage6_field_expr("stage6.booleanity.gamma_sq_0", Stage6FieldExprKind::Pow(0), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_1", Stage6FieldExprKind::Pow(2), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_2", Stage6FieldExprKind::Pow(4), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_3", Stage6FieldExprKind::Pow(6), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_4", Stage6FieldExprKind::Pow(8), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_5", Stage6FieldExprKind::Pow(10), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_6", Stage6FieldExprKind::Pow(12), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_7", Stage6FieldExprKind::Pow(14), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.gamma_sq_8", Stage6FieldExprKind::Pow(16), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_9", Stage6FieldExprKind::Pow(18), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_10", Stage6FieldExprKind::Pow(20), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_11", Stage6FieldExprKind::Pow(22), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_12", Stage6FieldExprKind::Pow(24), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_13", Stage6FieldExprKind::Pow(26), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_14", Stage6FieldExprKind::Pow(28), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_15", Stage6FieldExprKind::Pow(30), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.gamma_sq_16", Stage6FieldExprKind::Pow(32), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_17", Stage6FieldExprKind::Pow(34), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_18", Stage6FieldExprKind::Pow(36), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_19", Stage6FieldExprKind::Pow(38), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_20", Stage6FieldExprKind::Pow(40), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_21", Stage6FieldExprKind::Pow(42), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_22", Stage6FieldExprKind::Pow(44), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_23", Stage6FieldExprKind::Pow(46), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.gamma_sq_24", Stage6FieldExprKind::Pow(48), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_25", Stage6FieldExprKind::Pow(50), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_26", Stage6FieldExprKind::Pow(52), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_27", Stage6FieldExprKind::Pow(54), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_28", Stage6FieldExprKind::Pow(56), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_29", Stage6FieldExprKind::Pow(58), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_30", Stage6FieldExprKind::Pow(60), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_31", Stage6FieldExprKind::Pow(62), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.gamma_sq_32", Stage6FieldExprKind::Pow(64), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_33", Stage6FieldExprKind::Pow(66), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_34", Stage6FieldExprKind::Pow(68), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_35", Stage6FieldExprKind::Pow(70), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_36", Stage6FieldExprKind::Pow(72), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_37", Stage6FieldExprKind::Pow(74), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_38", Stage6FieldExprKind::Pow(76), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_0", Stage6FieldExprKind::Pow(0), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_8", Stage6FieldExprKind::Pow(8), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.gamma_pow_9", Stage6FieldExprKind::Pow(9), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_10", Stage6FieldExprKind::Pow(10), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_11", Stage6FieldExprKind::Pow(11), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_12", Stage6FieldExprKind::Pow(12), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_13", Stage6FieldExprKind::Pow(13), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_14", Stage6FieldExprKind::Pow(14), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_15", Stage6FieldExprKind::Pow(15), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_16", Stage6FieldExprKind::Pow(16), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.gamma_pow_17", Stage6FieldExprKind::Pow(17), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_18", Stage6FieldExprKind::Pow(18), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_19", Stage6FieldExprKind::Pow(19), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_20", Stage6FieldExprKind::Pow(20), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_21", Stage6FieldExprKind::Pow(21), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_22", Stage6FieldExprKind::Pow(22), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_23", Stage6FieldExprKind::Pow(23), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_24", Stage6FieldExprKind::Pow(24), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.gamma_pow_25", Stage6FieldExprKind::Pow(25), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_26", Stage6FieldExprKind::Pow(26), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_27", Stage6FieldExprKind::Pow(27), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_28", Stage6FieldExprKind::Pow(28), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_29", Stage6FieldExprKind::Pow(29), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_30", Stage6FieldExprKind::Pow(30), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_31", Stage6FieldExprKind::Pow(31), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_32", Stage6FieldExprKind::Pow(32), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.gamma_pow_33", Stage6FieldExprKind::Pow(33), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_34", Stage6FieldExprKind::Pow(34), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_35", Stage6FieldExprKind::Pow(35), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_36", Stage6FieldExprKind::Pow(36), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_37", Stage6FieldExprKind::Pow(37), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_38", Stage6FieldExprKind::Pow(38), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term1.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", "stage6.input.stage1.Imm"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term2.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", "stage6.input.stage1.OpFlagAddOperands"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term3.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", "stage6.input.stage1.OpFlagSubtractOperands"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term4.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", "stage6.input.stage1.OpFlagMultiplyOperands"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term5.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", "stage6.input.stage1.OpFlagLoad"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term6.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", "stage6.input.stage1.OpFlagStore"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term7.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", "stage6.input.stage1.OpFlagJump"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term8.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", "stage6.input.stage1.OpFlagWriteLookupOutputToRD"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term9.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", "stage6.input.stage1.OpFlagVirtualInstruction"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term10.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", "stage6.input.stage1.OpFlagAssert"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term11.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term12.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", "stage6.input.stage1.OpFlagAdvice"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term13.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", "stage6.input.stage1.OpFlagIsCompressed"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term14.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", "stage6.input.stage1.OpFlagIsFirstInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term15.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", "stage6.input.stage1.OpFlagIsLastInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term16.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term16.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term16.gamma_pow", "stage6.input.stage2.OpFlagJump"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", "stage6.input.stage2.InstructionFlagBranch"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term17.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.gamma_pow", "stage6.bytecode_read_raf.claim.term17.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", "stage6.input.stage2.OpFlagWriteLookupOutputToRD"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.gamma_pow", "stage6.bytecode_read_raf.claim.term18.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", "stage6.input.stage2.OpFlagVirtualInstruction"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term19.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.gamma_pow", "stage6.bytecode_read_raf.claim.term19.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term20.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term20.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term20.gamma_pow", "stage6.input.stage3.instruction_input.Imm"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", "stage6.input.stage3.spartan_shift.UnexpandedPC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.gamma_pow", "stage6.bytecode_read_raf.claim.term21.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.gamma_pow", "stage6.bytecode_read_raf.claim.term22.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.gamma_pow", "stage6.bytecode_read_raf.claim.term23.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.gamma_pow", "stage6.bytecode_read_raf.claim.term24.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.gamma_pow", "stage6.bytecode_read_raf.claim.term25.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.gamma_pow", "stage6.bytecode_read_raf.claim.term26.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.gamma_pow", "stage6.bytecode_read_raf.claim.term27.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.gamma_pow", "stage6.bytecode_read_raf.claim.term28.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term29.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term29.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term29.gamma_pow", "stage6.input.stage4.RdWa"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", "stage6.input.stage4.Rs1Ra"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term30.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.gamma_pow", "stage6.bytecode_read_raf.claim.term30.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", "stage6.input.stage4.Rs2Ra"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.gamma_pow", "stage6.bytecode_read_raf.claim.term31.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term32.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term32.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term32.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdWa"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", "stage6.input.stage5.InstructionRafFlag"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.gamma_pow", "stage6.bytecode_read_raf.claim.term33.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_0"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.gamma_pow", "stage6.bytecode_read_raf.claim.term34.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_1"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.gamma_pow", "stage6.bytecode_read_raf.claim.term35.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_2"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.gamma_pow", "stage6.bytecode_read_raf.claim.term36.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_3"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.gamma_pow", "stage6.bytecode_read_raf.claim.term37.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_4"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.gamma_pow", "stage6.bytecode_read_raf.claim.term38.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_5"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.gamma_pow", "stage6.bytecode_read_raf.claim.term39.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_6"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.gamma_pow", "stage6.bytecode_read_raf.claim.term40.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_7"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.gamma_pow", "stage6.bytecode_read_raf.claim.term41.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_8"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.gamma_pow", "stage6.bytecode_read_raf.claim.term42.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_9"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.gamma_pow", "stage6.bytecode_read_raf.claim.term43.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_10"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.gamma_pow", "stage6.bytecode_read_raf.claim.term44.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_11"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.gamma_pow", "stage6.bytecode_read_raf.claim.term45.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_12"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.gamma_pow", "stage6.bytecode_read_raf.claim.term46.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_13"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.gamma_pow", "stage6.bytecode_read_raf.claim.term47.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", Stage6FieldExprKind::Pow(16), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_14"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.gamma_pow", "stage6.bytecode_read_raf.claim.term48.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", Stage6FieldExprKind::Pow(17), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_15"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.gamma_pow", "stage6.bytecode_read_raf.claim.term49.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", Stage6FieldExprKind::Pow(18), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_16"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.gamma_pow", "stage6.bytecode_read_raf.claim.term50.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", Stage6FieldExprKind::Pow(19), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_17"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.gamma_pow", "stage6.bytecode_read_raf.claim.term51.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", Stage6FieldExprKind::Pow(20), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_18"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.gamma_pow", "stage6.bytecode_read_raf.claim.term52.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", Stage6FieldExprKind::Pow(21), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_19"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.gamma_pow", "stage6.bytecode_read_raf.claim.term53.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", Stage6FieldExprKind::Pow(22), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_20"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.gamma_pow", "stage6.bytecode_read_raf.claim.term54.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", Stage6FieldExprKind::Pow(23), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_21"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.gamma_pow", "stage6.bytecode_read_raf.claim.term55.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", Stage6FieldExprKind::Pow(24), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_22"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.gamma_pow", "stage6.bytecode_read_raf.claim.term56.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", Stage6FieldExprKind::Pow(25), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_23"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.gamma_pow", "stage6.bytecode_read_raf.claim.term57.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", Stage6FieldExprKind::Pow(26), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_24"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.gamma_pow", "stage6.bytecode_read_raf.claim.term58.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", Stage6FieldExprKind::Pow(27), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_25"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.gamma_pow", "stage6.bytecode_read_raf.claim.term59.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", Stage6FieldExprKind::Pow(28), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_26"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.gamma_pow", "stage6.bytecode_read_raf.claim.term60.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", Stage6FieldExprKind::Pow(29), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_27"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.gamma_pow", "stage6.bytecode_read_raf.claim.term61.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", Stage6FieldExprKind::Pow(30), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_28"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.gamma_pow", "stage6.bytecode_read_raf.claim.term62.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", Stage6FieldExprKind::Pow(31), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_29"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.gamma_pow", "stage6.bytecode_read_raf.claim.term63.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", Stage6FieldExprKind::Pow(32), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_30"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.gamma_pow", "stage6.bytecode_read_raf.claim.term64.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", Stage6FieldExprKind::Pow(33), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_31"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.gamma_pow", "stage6.bytecode_read_raf.claim.term65.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", Stage6FieldExprKind::Pow(34), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_32"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.gamma_pow", "stage6.bytecode_read_raf.claim.term66.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", Stage6FieldExprKind::Pow(35), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_33"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.gamma_pow", "stage6.bytecode_read_raf.claim.term67.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", Stage6FieldExprKind::Pow(36), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_34"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.gamma_pow", "stage6.bytecode_read_raf.claim.term68.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", Stage6FieldExprKind::Pow(37), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_35"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.gamma_pow", "stage6.bytecode_read_raf.claim.term69.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", Stage6FieldExprKind::Pow(38), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_36"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.gamma_pow", "stage6.bytecode_read_raf.claim.term70.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", Stage6FieldExprKind::Pow(39), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_37"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.gamma_pow", "stage6.bytecode_read_raf.claim.term71.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", Stage6FieldExprKind::Pow(40), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_38"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.gamma_pow", "stage6.bytecode_read_raf.claim.term72.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", Stage6FieldExprKind::Pow(41), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_39"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.gamma_pow", "stage6.bytecode_read_raf.claim.term73.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", Stage6FieldExprKind::Pow(42), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_40"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.gamma_pow", "stage6.bytecode_read_raf.claim.term74.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term75.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term75.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term75.gamma_pow", "stage6.input.stage1.PC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term76.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term76.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term76.gamma_pow", "stage6.input.stage3.spartan_shift.PC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.entry_constant", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage1.UnexpandedPC", "stage6.bytecode_read_raf.claim.term1.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial0", "stage6.bytecode_read_raf.claim.term2.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial1", "stage6.bytecode_read_raf.claim.term3.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial2", "stage6.bytecode_read_raf.claim.term4.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial3", "stage6.bytecode_read_raf.claim.term5.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial4", "stage6.bytecode_read_raf.claim.term6.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial5", "stage6.bytecode_read_raf.claim.term7.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial7", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial6", "stage6.bytecode_read_raf.claim.term8.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial8", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial7", "stage6.bytecode_read_raf.claim.term9.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial9", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial8", "stage6.bytecode_read_raf.claim.term10.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial10", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial9", "stage6.bytecode_read_raf.claim.term11.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial11", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial10", "stage6.bytecode_read_raf.claim.term12.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial12", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial11", "stage6.bytecode_read_raf.claim.term13.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial13", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial12", "stage6.bytecode_read_raf.claim.term14.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial14", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial13", "stage6.bytecode_read_raf.claim.term15.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial15", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial14", "stage6.bytecode_read_raf.claim.term16.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial16", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial15", "stage6.bytecode_read_raf.claim.term17.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial17", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial16", "stage6.bytecode_read_raf.claim.term18.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial18", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial17", "stage6.bytecode_read_raf.claim.term19.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial19", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial18", "stage6.bytecode_read_raf.claim.term20.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial20", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial19", "stage6.bytecode_read_raf.claim.term21.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial21", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial20", "stage6.bytecode_read_raf.claim.term22.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial22", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial21", "stage6.bytecode_read_raf.claim.term23.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial23", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial22", "stage6.bytecode_read_raf.claim.term24.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial24", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial23", "stage6.bytecode_read_raf.claim.term25.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial25", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial24", "stage6.bytecode_read_raf.claim.term26.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial26", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial25", "stage6.bytecode_read_raf.claim.term27.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial27", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial26", "stage6.bytecode_read_raf.claim.term28.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial28", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial27", "stage6.bytecode_read_raf.claim.term29.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial29", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial28", "stage6.bytecode_read_raf.claim.term30.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial30", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial29", "stage6.bytecode_read_raf.claim.term31.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial31", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial30", "stage6.bytecode_read_raf.claim.term32.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial32", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial31", "stage6.bytecode_read_raf.claim.term33.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial33", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial32", "stage6.bytecode_read_raf.claim.term34.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial34", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial33", "stage6.bytecode_read_raf.claim.term35.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial35", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial34", "stage6.bytecode_read_raf.claim.term36.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial36", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial35", "stage6.bytecode_read_raf.claim.term37.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial37", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial36", "stage6.bytecode_read_raf.claim.term38.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial38", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial37", "stage6.bytecode_read_raf.claim.term39.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial39", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial38", "stage6.bytecode_read_raf.claim.term40.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial40", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial39", "stage6.bytecode_read_raf.claim.term41.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial41", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial40", "stage6.bytecode_read_raf.claim.term42.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial42", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial41", "stage6.bytecode_read_raf.claim.term43.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial43", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial42", "stage6.bytecode_read_raf.claim.term44.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial44", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial43", "stage6.bytecode_read_raf.claim.term45.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial45", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial44", "stage6.bytecode_read_raf.claim.term46.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial46", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial45", "stage6.bytecode_read_raf.claim.term47.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial47", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial46", "stage6.bytecode_read_raf.claim.term48.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial48", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial47", "stage6.bytecode_read_raf.claim.term49.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial49", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial48", "stage6.bytecode_read_raf.claim.term50.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial50", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial49", "stage6.bytecode_read_raf.claim.term51.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial51", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial50", "stage6.bytecode_read_raf.claim.term52.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial52", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial51", "stage6.bytecode_read_raf.claim.term53.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial53", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial52", "stage6.bytecode_read_raf.claim.term54.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial54", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial53", "stage6.bytecode_read_raf.claim.term55.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial55", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial54", "stage6.bytecode_read_raf.claim.term56.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial56", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial55", "stage6.bytecode_read_raf.claim.term57.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial57", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial56", "stage6.bytecode_read_raf.claim.term58.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial58", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial57", "stage6.bytecode_read_raf.claim.term59.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial59", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial58", "stage6.bytecode_read_raf.claim.term60.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial60", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial59", "stage6.bytecode_read_raf.claim.term61.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial61", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial60", "stage6.bytecode_read_raf.claim.term62.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial62", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial61", "stage6.bytecode_read_raf.claim.term63.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial63", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial62", "stage6.bytecode_read_raf.claim.term64.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial64", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial63", "stage6.bytecode_read_raf.claim.term65.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial65", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial64", "stage6.bytecode_read_raf.claim.term66.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial66", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial65", "stage6.bytecode_read_raf.claim.term67.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial67", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial66", "stage6.bytecode_read_raf.claim.term68.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial68", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial67", "stage6.bytecode_read_raf.claim.term69.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial69", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial68", "stage6.bytecode_read_raf.claim.term70.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial70", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial69", "stage6.bytecode_read_raf.claim.term71.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial71", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial70", "stage6.bytecode_read_raf.claim.term72.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial72", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial71", "stage6.bytecode_read_raf.claim.term73.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial73", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial72", "stage6.bytecode_read_raf.claim.term74.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial74", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial73", "stage6.bytecode_read_raf.claim.term75.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial75", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial74", "stage6.bytecode_read_raf.claim.term76.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial76", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial75", "stage6.bytecode_read_raf.claim.entry_constant"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term1.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term1.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term1.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_1"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term2.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term2.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term2.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_2"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term3.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_3"]), + stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), + stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), + stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -377,35 +375,33 @@ pub const STAGE6_SUMCHECK_INSTANCE_RESULTS: &[Stage6SumcheckInstanceResultPlan] Stage6SumcheckInstanceResultPlan { symbol: "stage6.inc_claim_reduction.instance", source: "stage6.sumcheck", claim: "stage6.inc_claim_reduction.input", relation: Stage6RelationKind::Stage6IncClaimReduction, index: 5, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 2 }, ]; -macro_rules! stage6_sumcheck_eval { - ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => { - Stage6SumcheckEvalPlan { symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle } - }; +const fn stage6_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage6SumcheckEvalPlan { + Stage6SumcheckEvalPlan { symbol, source, name, index, oracle } } #[rustfmt::skip] pub const STAGE6_SUMCHECK_EVALS: &[Stage6SumcheckEvalPlan] = &[ - stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_0", 0, "BytecodeRa_0"), stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_1", 1, "BytecodeRa_1"), stage6_sumcheck_eval!("stage6.bytecode_read_raf.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_2", 2, "BytecodeRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_0", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_0", 0, "InstructionRa_0"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_1", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_2", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_3", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_4", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_4", 4, "InstructionRa_4"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_5", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_6", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_7", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_8", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_8", 8, "InstructionRa_8"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_9", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_10", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_11", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_12", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_12", 12, "InstructionRa_12"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_13", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_14", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_15", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_16", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_16", 16, "InstructionRa_16"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_17", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_18", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_19", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_20", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_20", 20, "InstructionRa_20"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_21", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_22", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_23", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_24", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_24", 24, "InstructionRa_24"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_25", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_26", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_27", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_28", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_28", 28, "InstructionRa_28"), - stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_29", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_30", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval!("stage6.booleanity.eval.InstructionRa_31", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_0", 32, "BytecodeRa_0"), - stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage6_sumcheck_eval!("stage6.booleanity.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_0", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_0", 35, "RamRa_0"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_1", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_1", 36, "RamRa_1"), - stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_2", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_2", 37, "RamRa_2"), stage6_sumcheck_eval!("stage6.booleanity.eval.RamRa_3", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_3", 38, "RamRa_3"), stage6_sumcheck_eval!("stage6.hamming_booleanity.eval.HammingWeight", "stage6.sumcheck", "stage6.hamming_booleanity.eval.HammingWeight", 0, "HammingWeight"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_0", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_0", 0, "RamRa_0"), - stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_1", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_1", 1, "RamRa_1"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_2", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_2", 2, "RamRa_2"), stage6_sumcheck_eval!("stage6.ram_ra_virtual.eval.RamRa_3", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_3", 3, "RamRa_3"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_0", 0, "InstructionRa_0"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_4", 4, "InstructionRa_4"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_8", 8, "InstructionRa_8"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_12", 12, "InstructionRa_12"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_16", 16, "InstructionRa_16"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_20", 20, "InstructionRa_20"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_24", 24, "InstructionRa_24"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_28", 28, "InstructionRa_28"), - stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval!("stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval!("stage6.inc_claim_reduction.eval.RamInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RamInc", 0, "RamInc"), - stage6_sumcheck_eval!("stage6.inc_claim_reduction.eval.RdInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RdInc", 1, "RdInc"), + stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_0", 0, "BytecodeRa_0"), stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_1", 1, "BytecodeRa_1"), stage6_sumcheck_eval("stage6.bytecode_read_raf.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.bytecode_read_raf.eval.BytecodeRa_2", 2, "BytecodeRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_0", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_0", 0, "InstructionRa_0"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_1", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_2", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_3", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_4", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_4", 4, "InstructionRa_4"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_5", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_6", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_7", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_8", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_8", 8, "InstructionRa_8"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_9", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_10", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_11", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_12", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_12", 12, "InstructionRa_12"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_13", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_14", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_15", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_16", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_16", 16, "InstructionRa_16"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_17", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_18", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_19", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_20", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_20", 20, "InstructionRa_20"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_21", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_22", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_23", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_24", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_24", 24, "InstructionRa_24"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_25", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_26", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_27", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_28", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_28", 28, "InstructionRa_28"), + stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_29", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_30", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval("stage6.booleanity.eval.InstructionRa_31", "stage6.sumcheck", "stage6.booleanity.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_0", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_0", 32, "BytecodeRa_0"), + stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_1", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage6_sumcheck_eval("stage6.booleanity.eval.BytecodeRa_2", "stage6.sumcheck", "stage6.booleanity.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_0", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_0", 35, "RamRa_0"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_1", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_1", 36, "RamRa_1"), + stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_2", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_2", 37, "RamRa_2"), stage6_sumcheck_eval("stage6.booleanity.eval.RamRa_3", "stage6.sumcheck", "stage6.booleanity.eval.RamRa_3", 38, "RamRa_3"), stage6_sumcheck_eval("stage6.hamming_booleanity.eval.HammingWeight", "stage6.sumcheck", "stage6.hamming_booleanity.eval.HammingWeight", 0, "HammingWeight"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_0", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_0", 0, "RamRa_0"), + stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_1", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_1", 1, "RamRa_1"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_2", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_2", 2, "RamRa_2"), stage6_sumcheck_eval("stage6.ram_ra_virtual.eval.RamRa_3", "stage6.sumcheck", "stage6.ram_ra_virtual.eval.RamRa_3", 3, "RamRa_3"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_0", 0, "InstructionRa_0"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_1", 1, "InstructionRa_1"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_2", 2, "InstructionRa_2"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_3", 3, "InstructionRa_3"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_4", 4, "InstructionRa_4"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_5", 5, "InstructionRa_5"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_6", 6, "InstructionRa_6"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_7", 7, "InstructionRa_7"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_8", 8, "InstructionRa_8"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_9", 9, "InstructionRa_9"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_10", 10, "InstructionRa_10"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_11", 11, "InstructionRa_11"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_12", 12, "InstructionRa_12"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_13", 13, "InstructionRa_13"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_14", 14, "InstructionRa_14"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_15", 15, "InstructionRa_15"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_16", 16, "InstructionRa_16"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_17", 17, "InstructionRa_17"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_18", 18, "InstructionRa_18"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_19", 19, "InstructionRa_19"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_20", 20, "InstructionRa_20"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_21", 21, "InstructionRa_21"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_22", 22, "InstructionRa_22"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_23", 23, "InstructionRa_23"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_24", 24, "InstructionRa_24"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_25", 25, "InstructionRa_25"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_26", 26, "InstructionRa_26"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_27", 27, "InstructionRa_27"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_28", 28, "InstructionRa_28"), + stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_29", 29, "InstructionRa_29"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_30", 30, "InstructionRa_30"), stage6_sumcheck_eval("stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.sumcheck", "stage6.instruction_ra_virtual.eval.InstructionRa_31", 31, "InstructionRa_31"), stage6_sumcheck_eval("stage6.inc_claim_reduction.eval.RamInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RamInc", 0, "RamInc"), + stage6_sumcheck_eval("stage6.inc_claim_reduction.eval.RdInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RdInc", 1, "RdInc"), ]; pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[ diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 739448c99e..fe1c504728 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -152,58 +152,56 @@ pub const STAGE7_FIELD_CONSTANTS: &[Stage7FieldConstantPlan] = &[ Stage7FieldConstantPlan { symbol: "stage7.field.one", field: "bn254_fr", value: 1 }, ]; -macro_rules! stage7_field_expr { - ($symbol:literal, $kind:expr, $operands:expr) => { - Stage7FieldExprPlan { symbol: $symbol, kind: $kind, operands: $operands } - }; +const fn stage7_field_expr(symbol: &'static str, kind: Stage7FieldExprKind, operands: &'static [&'static str]) -> Stage7FieldExprPlan { + Stage7FieldExprPlan { symbol, kind, operands } } #[rustfmt::skip] pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[ - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", Stage7FieldExprKind::Pow(1), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", Stage7FieldExprKind::Pow(2), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", Stage7FieldExprKind::Pow(3), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", Stage7FieldExprKind::Pow(4), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_1"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", Stage7FieldExprKind::Pow(5), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", Stage7FieldExprKind::Pow(6), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", Stage7FieldExprKind::Pow(7), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_2"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", Stage7FieldExprKind::Pow(8), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", Stage7FieldExprKind::Pow(9), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", Stage7FieldExprKind::Pow(10), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_3"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", Stage7FieldExprKind::Pow(11), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", Stage7FieldExprKind::Pow(12), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", Stage7FieldExprKind::Pow(13), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_4"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", Stage7FieldExprKind::Pow(14), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", Stage7FieldExprKind::Pow(15), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", Stage7FieldExprKind::Pow(16), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_5"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", Stage7FieldExprKind::Pow(17), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", Stage7FieldExprKind::Pow(18), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", Stage7FieldExprKind::Pow(19), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_6"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", Stage7FieldExprKind::Pow(20), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", Stage7FieldExprKind::Pow(21), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", Stage7FieldExprKind::Pow(22), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_7"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", Stage7FieldExprKind::Pow(23), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", Stage7FieldExprKind::Pow(24), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", Stage7FieldExprKind::Pow(25), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_8"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", Stage7FieldExprKind::Pow(26), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", Stage7FieldExprKind::Pow(27), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", Stage7FieldExprKind::Pow(28), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_9"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", Stage7FieldExprKind::Pow(29), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", Stage7FieldExprKind::Pow(30), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", Stage7FieldExprKind::Pow(31), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_10"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", Stage7FieldExprKind::Pow(32), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", Stage7FieldExprKind::Pow(33), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", Stage7FieldExprKind::Pow(34), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_11"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", Stage7FieldExprKind::Pow(35), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", Stage7FieldExprKind::Pow(36), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", Stage7FieldExprKind::Pow(37), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_12"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", Stage7FieldExprKind::Pow(38), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", Stage7FieldExprKind::Pow(39), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", Stage7FieldExprKind::Pow(40), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_13"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", Stage7FieldExprKind::Pow(41), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", Stage7FieldExprKind::Pow(42), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", Stage7FieldExprKind::Pow(43), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_14"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", Stage7FieldExprKind::Pow(44), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", Stage7FieldExprKind::Pow(45), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", Stage7FieldExprKind::Pow(46), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_15"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", Stage7FieldExprKind::Pow(47), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", Stage7FieldExprKind::Pow(48), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", Stage7FieldExprKind::Pow(49), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_16"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", Stage7FieldExprKind::Pow(50), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", Stage7FieldExprKind::Pow(51), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", Stage7FieldExprKind::Pow(52), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_17"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", Stage7FieldExprKind::Pow(53), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", Stage7FieldExprKind::Pow(54), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", Stage7FieldExprKind::Pow(55), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_18"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", Stage7FieldExprKind::Pow(56), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", Stage7FieldExprKind::Pow(57), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", Stage7FieldExprKind::Pow(58), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_19"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", Stage7FieldExprKind::Pow(59), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", Stage7FieldExprKind::Pow(60), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", Stage7FieldExprKind::Pow(61), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_20"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", Stage7FieldExprKind::Pow(62), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", Stage7FieldExprKind::Pow(63), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", Stage7FieldExprKind::Pow(64), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_21"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", Stage7FieldExprKind::Pow(65), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", Stage7FieldExprKind::Pow(66), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", Stage7FieldExprKind::Pow(67), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_22"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", Stage7FieldExprKind::Pow(68), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", Stage7FieldExprKind::Pow(69), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", Stage7FieldExprKind::Pow(70), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_23"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", Stage7FieldExprKind::Pow(71), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", Stage7FieldExprKind::Pow(72), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", Stage7FieldExprKind::Pow(73), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_24"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", Stage7FieldExprKind::Pow(74), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", Stage7FieldExprKind::Pow(75), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", Stage7FieldExprKind::Pow(76), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_25"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", Stage7FieldExprKind::Pow(77), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", Stage7FieldExprKind::Pow(78), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", Stage7FieldExprKind::Pow(79), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_26"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", Stage7FieldExprKind::Pow(80), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", Stage7FieldExprKind::Pow(81), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", Stage7FieldExprKind::Pow(82), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_27"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", Stage7FieldExprKind::Pow(83), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", Stage7FieldExprKind::Pow(84), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", Stage7FieldExprKind::Pow(85), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_28"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", Stage7FieldExprKind::Pow(86), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", Stage7FieldExprKind::Pow(87), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", Stage7FieldExprKind::Pow(88), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_29"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", Stage7FieldExprKind::Pow(89), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", Stage7FieldExprKind::Pow(90), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", Stage7FieldExprKind::Pow(91), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_30"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", Stage7FieldExprKind::Pow(92), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", Stage7FieldExprKind::Pow(93), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", Stage7FieldExprKind::Pow(94), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_31"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", Stage7FieldExprKind::Pow(95), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", Stage7FieldExprKind::Pow(96), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", Stage7FieldExprKind::Pow(97), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", Stage7FieldExprKind::Pow(98), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", Stage7FieldExprKind::Pow(99), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", Stage7FieldExprKind::Pow(100), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_1"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", Stage7FieldExprKind::Pow(101), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", Stage7FieldExprKind::Pow(102), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", Stage7FieldExprKind::Pow(103), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_2"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", Stage7FieldExprKind::Pow(104), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", Stage7FieldExprKind::Pow(105), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", Stage7FieldExprKind::Pow(106), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", Stage7FieldExprKind::Pow(107), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_0"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", Stage7FieldExprKind::Pow(108), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", Stage7FieldExprKind::Pow(109), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_1"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", Stage7FieldExprKind::Pow(110), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_1"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", Stage7FieldExprKind::Pow(111), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", Stage7FieldExprKind::Pow(112), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_2"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", Stage7FieldExprKind::Pow(113), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_2"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", Stage7FieldExprKind::Pow(114), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", Stage7FieldExprKind::Pow(115), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_3"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", Stage7FieldExprKind::Pow(116), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial0", Stage7FieldExprKind::Add, &["stage7.field.one", "stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial1", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial0", "stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial2", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial1", "stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial3", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial2", "stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial4", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial3", "stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial5", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial4", "stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial6", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial5", "stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial7", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial6", "stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial8", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial7", "stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial9", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial8", "stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial10", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial9", "stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial11", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial10", "stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial12", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial11", "stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial13", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial12", "stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial14", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial13", "stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial15", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial14", "stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial16", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial15", "stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial17", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial16", "stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial18", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial17", "stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial19", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial18", "stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial20", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial19", "stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial21", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial20", "stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial22", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial21", "stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial23", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial22", "stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial24", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial23", "stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial25", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial24", "stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial26", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial25", "stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial27", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial26", "stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial28", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial27", "stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial29", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial28", "stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial30", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial29", "stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial31", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial30", "stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial32", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial31", "stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial33", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial32", "stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial34", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial33", "stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial35", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial34", "stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial36", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial35", "stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial37", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial36", "stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial38", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial37", "stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial39", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial38", "stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial40", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial39", "stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial41", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial40", "stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial42", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial41", "stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial43", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial42", "stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial44", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial43", "stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial45", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial44", "stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial46", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial45", "stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial47", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial46", "stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial48", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial47", "stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial49", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial48", "stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial50", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial49", "stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial51", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial50", "stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial52", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial51", "stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial53", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial52", "stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial54", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial53", "stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial55", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial54", "stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial56", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial55", "stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial57", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial56", "stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial58", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial57", "stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial59", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial58", "stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial60", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial59", "stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial61", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial60", "stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial62", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial61", "stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial63", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial62", "stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial64", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial63", "stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial65", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial64", "stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial66", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial65", "stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial67", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial66", "stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial68", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial67", "stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial69", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial68", "stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial70", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial69", "stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial71", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial70", "stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial72", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial71", "stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial73", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial72", "stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial74", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial73", "stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial75", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial74", "stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial76", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial75", "stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial77", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial76", "stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial78", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial77", "stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial79", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial78", "stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial80", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial79", "stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial81", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial80", "stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial82", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial81", "stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial83", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial82", "stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial84", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial83", "stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial85", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial84", "stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial86", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial85", "stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial87", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial86", "stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial88", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial87", "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial89", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial88", "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial90", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial89", "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial91", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial90", "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial92", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial91", "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial93", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial92", "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial94", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial93", "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial95", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial94", "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial96", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial95", "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial97", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial96", "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial98", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial97", "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial99", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial98", "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial100", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial99", "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial101", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial100", "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial102", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial101", "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial103", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial102", "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial104", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial103", "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial105", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial104", "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial106", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial105", "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial107", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial106", "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial108", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial107", "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial109", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial108", "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial110", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial109", "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial111", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial110", "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"]), - stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"]), stage7_field_expr!("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", Stage7FieldExprKind::Pow(1), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", Stage7FieldExprKind::Pow(2), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", Stage7FieldExprKind::Pow(3), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", Stage7FieldExprKind::Pow(4), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_1"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", Stage7FieldExprKind::Pow(5), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", Stage7FieldExprKind::Pow(6), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", Stage7FieldExprKind::Pow(7), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", Stage7FieldExprKind::Pow(8), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", Stage7FieldExprKind::Pow(9), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", Stage7FieldExprKind::Pow(10), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", Stage7FieldExprKind::Pow(11), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", Stage7FieldExprKind::Pow(12), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", Stage7FieldExprKind::Pow(13), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_4"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", Stage7FieldExprKind::Pow(14), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", Stage7FieldExprKind::Pow(15), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", Stage7FieldExprKind::Pow(16), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_5"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", Stage7FieldExprKind::Pow(17), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", Stage7FieldExprKind::Pow(18), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", Stage7FieldExprKind::Pow(19), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_6"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", Stage7FieldExprKind::Pow(20), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", Stage7FieldExprKind::Pow(21), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", Stage7FieldExprKind::Pow(22), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_7"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", Stage7FieldExprKind::Pow(23), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", Stage7FieldExprKind::Pow(24), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", Stage7FieldExprKind::Pow(25), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_8"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", Stage7FieldExprKind::Pow(26), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", Stage7FieldExprKind::Pow(27), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", Stage7FieldExprKind::Pow(28), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_9"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", Stage7FieldExprKind::Pow(29), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", Stage7FieldExprKind::Pow(30), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", Stage7FieldExprKind::Pow(31), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_10"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", Stage7FieldExprKind::Pow(32), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", Stage7FieldExprKind::Pow(33), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", Stage7FieldExprKind::Pow(34), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_11"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", Stage7FieldExprKind::Pow(35), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", Stage7FieldExprKind::Pow(36), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", Stage7FieldExprKind::Pow(37), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_12"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", Stage7FieldExprKind::Pow(38), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", Stage7FieldExprKind::Pow(39), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", Stage7FieldExprKind::Pow(40), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_13"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", Stage7FieldExprKind::Pow(41), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", Stage7FieldExprKind::Pow(42), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", Stage7FieldExprKind::Pow(43), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_14"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", Stage7FieldExprKind::Pow(44), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", Stage7FieldExprKind::Pow(45), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", Stage7FieldExprKind::Pow(46), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_15"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", Stage7FieldExprKind::Pow(47), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", Stage7FieldExprKind::Pow(48), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", Stage7FieldExprKind::Pow(49), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_16"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", Stage7FieldExprKind::Pow(50), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", Stage7FieldExprKind::Pow(51), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", Stage7FieldExprKind::Pow(52), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_17"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", Stage7FieldExprKind::Pow(53), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", Stage7FieldExprKind::Pow(54), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", Stage7FieldExprKind::Pow(55), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_18"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", Stage7FieldExprKind::Pow(56), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", Stage7FieldExprKind::Pow(57), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", Stage7FieldExprKind::Pow(58), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_19"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", Stage7FieldExprKind::Pow(59), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", Stage7FieldExprKind::Pow(60), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", Stage7FieldExprKind::Pow(61), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_20"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", Stage7FieldExprKind::Pow(62), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", Stage7FieldExprKind::Pow(63), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", Stage7FieldExprKind::Pow(64), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_21"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", Stage7FieldExprKind::Pow(65), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", Stage7FieldExprKind::Pow(66), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", Stage7FieldExprKind::Pow(67), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_22"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", Stage7FieldExprKind::Pow(68), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", Stage7FieldExprKind::Pow(69), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", Stage7FieldExprKind::Pow(70), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_23"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", Stage7FieldExprKind::Pow(71), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", Stage7FieldExprKind::Pow(72), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", Stage7FieldExprKind::Pow(73), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_24"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", Stage7FieldExprKind::Pow(74), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", Stage7FieldExprKind::Pow(75), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", Stage7FieldExprKind::Pow(76), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_25"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", Stage7FieldExprKind::Pow(77), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", Stage7FieldExprKind::Pow(78), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", Stage7FieldExprKind::Pow(79), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_26"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", Stage7FieldExprKind::Pow(80), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", Stage7FieldExprKind::Pow(81), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", Stage7FieldExprKind::Pow(82), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_27"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", Stage7FieldExprKind::Pow(83), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", Stage7FieldExprKind::Pow(84), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", Stage7FieldExprKind::Pow(85), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_28"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", Stage7FieldExprKind::Pow(86), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", Stage7FieldExprKind::Pow(87), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", Stage7FieldExprKind::Pow(88), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_29"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", Stage7FieldExprKind::Pow(89), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", Stage7FieldExprKind::Pow(90), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", Stage7FieldExprKind::Pow(91), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_30"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", Stage7FieldExprKind::Pow(92), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", Stage7FieldExprKind::Pow(93), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", Stage7FieldExprKind::Pow(94), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_31"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", Stage7FieldExprKind::Pow(95), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", Stage7FieldExprKind::Pow(96), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", "stage7.field.one"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", Stage7FieldExprKind::Pow(97), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", Stage7FieldExprKind::Pow(98), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", Stage7FieldExprKind::Pow(99), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", Stage7FieldExprKind::Pow(100), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_1"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", Stage7FieldExprKind::Pow(101), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", Stage7FieldExprKind::Pow(102), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", Stage7FieldExprKind::Pow(103), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", Stage7FieldExprKind::Pow(104), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", Stage7FieldExprKind::Pow(105), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", Stage7FieldExprKind::Pow(106), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", Stage7FieldExprKind::Pow(107), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", Stage7FieldExprKind::Pow(108), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", Stage7FieldExprKind::Pow(109), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", Stage7FieldExprKind::Pow(110), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", Stage7FieldExprKind::Pow(111), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", Stage7FieldExprKind::Pow(112), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_2"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", Stage7FieldExprKind::Pow(113), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", Stage7FieldExprKind::Pow(114), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", Stage7FieldExprKind::Pow(115), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", Stage7FieldExprKind::Pow(116), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial0", Stage7FieldExprKind::Add, &["stage7.field.one", "stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial1", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial0", "stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial2", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial1", "stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial3", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial2", "stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial4", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial3", "stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial5", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial4", "stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial6", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial5", "stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial7", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial6", "stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial8", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial7", "stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial9", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial8", "stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial10", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial9", "stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial11", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial10", "stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial12", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial11", "stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial13", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial12", "stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial14", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial13", "stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial15", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial14", "stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial16", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial15", "stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial17", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial16", "stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial18", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial17", "stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial19", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial18", "stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial20", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial19", "stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial21", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial20", "stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial22", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial21", "stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial23", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial22", "stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial24", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial23", "stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial25", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial24", "stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial26", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial25", "stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial27", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial26", "stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial28", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial27", "stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial29", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial28", "stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial30", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial29", "stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial31", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial30", "stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial32", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial31", "stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial33", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial32", "stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial34", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial33", "stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial35", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial34", "stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial36", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial35", "stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial37", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial36", "stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial38", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial37", "stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial39", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial38", "stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial40", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial39", "stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial41", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial40", "stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial42", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial41", "stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial43", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial42", "stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial44", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial43", "stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial45", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial44", "stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial46", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial45", "stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial47", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial46", "stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial48", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial47", "stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial49", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial48", "stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial50", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial49", "stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial51", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial50", "stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial52", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial51", "stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial53", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial52", "stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial54", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial53", "stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial55", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial54", "stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial56", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial55", "stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial57", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial56", "stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial58", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial57", "stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial59", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial58", "stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial60", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial59", "stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial61", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial60", "stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial62", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial61", "stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial63", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial62", "stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial64", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial63", "stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial65", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial64", "stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial66", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial65", "stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial67", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial66", "stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial68", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial67", "stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial69", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial68", "stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial70", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial69", "stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial71", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial70", "stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial72", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial71", "stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial73", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial72", "stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial74", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial73", "stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial75", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial74", "stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial76", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial75", "stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial77", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial76", "stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial78", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial77", "stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial79", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial78", "stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial80", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial79", "stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial81", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial80", "stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial82", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial81", "stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial83", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial82", "stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial84", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial83", "stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial85", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial84", "stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial86", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial85", "stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial87", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial86", "stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial88", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial87", "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial89", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial88", "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial90", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial89", "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial91", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial90", "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial92", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial91", "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial93", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial92", "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial94", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial93", "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial95", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial94", "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial96", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial95", "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial97", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial96", "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial98", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial97", "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial99", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial98", "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial100", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial99", "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial101", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial100", "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial102", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial101", "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial103", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial102", "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial104", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial103", "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial105", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial104", "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial106", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial105", "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial107", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial106", "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial108", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial107", "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial109", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial108", "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial110", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial109", "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial111", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial110", "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"]), ]; pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ @@ -226,24 +224,22 @@ pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] Stage7SumcheckInstanceResultPlan { symbol: "stage7.hamming_weight_claim_reduction.instance", source: "stage7.sumcheck", claim: "stage7.hamming_weight_claim_reduction.input", relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, index: 0, point_arity: 4, num_rounds: 4, round_offset: 0, point_order: "reverse", degree: 2 }, ]; -macro_rules! stage7_sumcheck_eval { - ($symbol:literal, $source:literal, $name:literal, $index:literal, $oracle:literal) => { - Stage7SumcheckEvalPlan { symbol: $symbol, source: $source, name: $name, index: $index, oracle: $oracle } - }; +const fn stage7_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage7SumcheckEvalPlan { + Stage7SumcheckEvalPlan { symbol, source, name, index, oracle } } #[rustfmt::skip] pub const STAGE7_SUMCHECK_EVALS: &[Stage7SumcheckEvalPlan] = &[ - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", 0, "InstructionRa_0"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", 1, "InstructionRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", 2, "InstructionRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", 3, "InstructionRa_3"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", 4, "InstructionRa_4"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", 5, "InstructionRa_5"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", 6, "InstructionRa_6"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", 7, "InstructionRa_7"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", 8, "InstructionRa_8"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", 9, "InstructionRa_9"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", 10, "InstructionRa_10"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", 11, "InstructionRa_11"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", 12, "InstructionRa_12"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", 13, "InstructionRa_13"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", 14, "InstructionRa_14"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", 15, "InstructionRa_15"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", 16, "InstructionRa_16"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", 17, "InstructionRa_17"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", 18, "InstructionRa_18"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", 19, "InstructionRa_19"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", 20, "InstructionRa_20"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", 21, "InstructionRa_21"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", 22, "InstructionRa_22"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", 23, "InstructionRa_23"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", 24, "InstructionRa_24"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", 25, "InstructionRa_25"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", 26, "InstructionRa_26"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", 27, "InstructionRa_27"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", 28, "InstructionRa_28"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", 29, "InstructionRa_29"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", 30, "InstructionRa_30"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", 31, "InstructionRa_31"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", 32, "BytecodeRa_0"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", 35, "RamRa_0"), - stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", 36, "RamRa_1"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", 37, "RamRa_2"), stage7_sumcheck_eval!("stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", 38, "RamRa_3"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", 0, "InstructionRa_0"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", 1, "InstructionRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", 2, "InstructionRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", 3, "InstructionRa_3"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", 4, "InstructionRa_4"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", 5, "InstructionRa_5"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", 6, "InstructionRa_6"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", 7, "InstructionRa_7"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", 8, "InstructionRa_8"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", 9, "InstructionRa_9"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", 10, "InstructionRa_10"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", 11, "InstructionRa_11"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", 12, "InstructionRa_12"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", 13, "InstructionRa_13"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", 14, "InstructionRa_14"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", 15, "InstructionRa_15"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", 16, "InstructionRa_16"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", 17, "InstructionRa_17"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", 18, "InstructionRa_18"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", 19, "InstructionRa_19"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", 20, "InstructionRa_20"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", 21, "InstructionRa_21"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", 22, "InstructionRa_22"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", 23, "InstructionRa_23"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", 24, "InstructionRa_24"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", 25, "InstructionRa_25"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", 26, "InstructionRa_26"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", 27, "InstructionRa_27"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", 28, "InstructionRa_28"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", 29, "InstructionRa_29"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", 30, "InstructionRa_30"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", 31, "InstructionRa_31"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", 32, "BytecodeRa_0"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", 33, "BytecodeRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", 34, "BytecodeRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", 35, "RamRa_0"), + stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", 36, "RamRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", 37, "RamRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", 38, "RamRa_3"), ]; pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[ From a22a430d089ec7efd852567548b0039f7b1f6839 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 20:08:19 -0600 Subject: [PATCH 013/171] refactor(bolt): trim verifier sumcheck plans --- .../src/protocols/jolt/emit/rust/stage1.rs | 8 +-- .../src/protocols/jolt/emit/rust/stage2.rs | 8 +-- .../src/protocols/jolt/emit/rust/stage3.rs | 8 +-- .../src/protocols/jolt/emit/rust/stage4.rs | 8 +-- .../src/protocols/jolt/emit/rust/stage5.rs | 8 +-- .../src/protocols/jolt/emit/rust/stage6.rs | 13 +++-- .../src/protocols/jolt/emit/rust/stage7.rs | 13 +++-- .../jolt/verifier_common.rs.template | 2 - crates/jolt-equivalence/src/plan_adapters.rs | 57 +++++++++++-------- crates/jolt-verifier/src/stages/common.rs | 2 - .../jolt-verifier/src/stages/stage1_outer.rs | 8 +-- crates/jolt-verifier/src/stages/stage2.rs | 16 +++--- crates/jolt-verifier/src/stages/stage3.rs | 8 +-- crates/jolt-verifier/src/stages/stage4.rs | 6 +- crates/jolt-verifier/src/stages/stage5.rs | 8 +-- crates/jolt-verifier/src/stages/stage6.rs | 23 +++++--- crates/jolt-verifier/src/stages/stage7.rs | 6 +- 17 files changed, 104 insertions(+), 98 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs index 841f0bf49e..fcb26cedc1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs @@ -866,13 +866,12 @@ impl Stage1CpuProgram { .enumerate() .map(|(index, batch)| { format!( - " Stage1SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE1_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", + " Stage1SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE1_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", rust_str(&batch.symbol), rust_str(&batch.stage), rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) @@ -1158,7 +1157,7 @@ pub enum VerifyStage1Error { .as_deref() .ok_or_else(|| missing_role_binding("verifier claim relation", &claim.symbol))?; claims.push(format!( - " Stage1SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {}, input_openings: {} }},", + " Stage1SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), rust_str(&claim.domain), @@ -1170,8 +1169,7 @@ pub enum VerifyStage1Error { &self.role, relation )?, - rust_str(&claim.claim_value), - super::plan_tokens::rust_str_slice_expr(&claim.input_openings) + rust_str(&claim.claim_value) )); } let claims = claims.join("\n"); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index f490ea2d79..73e865e936 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -1295,7 +1295,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); missing_role_binding("verifier claim relation", &claim.symbol) })?; claims.push(format!( - " Stage2SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {}, input_openings: {} }},", + " Stage2SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), rust_str(&claim.domain), @@ -1307,8 +1307,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); &self.role, relation )?, - rust_str(&claim.claim_value), - super::plan_tokens::rust_str_slice_expr(&claim.input_openings) + rust_str(&claim.claim_value) )); } } @@ -1337,13 +1336,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); .enumerate() .map(|(index, batch)| { format!( - " Stage2SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE2_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", + " Stage2SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE2_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", rust_str(&batch.symbol), rust_str(&batch.stage), rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 9180f5ccce..9a5d42f437 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1299,7 +1299,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); missing_role_binding("verifier claim relation", &claim.symbol) })?; claims.push(format!( - " Stage3SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {}, input_openings: {} }},", + " Stage3SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), rust_str(&claim.domain), @@ -1311,8 +1311,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); &self.role, relation )?, - rust_str(&claim.claim_value), - super::plan_tokens::rust_str_slice_expr(&claim.input_openings) + rust_str(&claim.claim_value) )); } } @@ -1341,13 +1340,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); .enumerate() .map(|(index, batch)| { format!( - " Stage3SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE3_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", + " Stage3SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE3_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", rust_str(&batch.symbol), rust_str(&batch.stage), rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index f690b8721e..fcb68cfcf3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -1482,7 +1482,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); .iter() .map(|claim| { Ok(format!( - " Stage4SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},", + " Stage4SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), rust_str(&claim.domain), @@ -1495,8 +1495,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); &self.role, claim.relation.as_deref() )?, - rust_str(&claim.claim_value), - super::plan_tokens::rust_str_slice_expr(&claim.input_openings) + rust_str(&claim.claim_value) )) }) .collect::, EmitError>>()? @@ -1561,13 +1560,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); .enumerate() .map(|(index, batch)| { format!( - " Stage4SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE4_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", + " Stage4SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE4_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", rust_str(&batch.symbol), rust_str(&batch.stage), rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index f4aefa2134..f01831a571 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1484,7 +1484,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); .iter() .map(|claim| { Ok(format!( - " Stage5SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},", + " Stage5SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), rust_str(&claim.domain), @@ -1497,8 +1497,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); &self.role, claim.relation.as_deref() )?, - rust_str(&claim.claim_value), - super::plan_tokens::rust_str_slice_expr(&claim.input_openings) + rust_str(&claim.claim_value) )) }) .collect::, EmitError>>()? @@ -1563,13 +1562,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); .enumerate() .map(|(index, batch)| { format!( - " Stage5SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE5_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", + " Stage5SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE5_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", rust_str(&batch.symbol), rust_str(&batch.stage), rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index e5993fb161..41711d9090 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1624,7 +1624,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); .iter() .map(|claim| { Ok(format!( - " Stage6SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},", + " Stage6SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), rust_str(&claim.domain), @@ -1637,8 +1637,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); &self.role, claim.relation.as_deref() )?, - rust_str(&claim.claim_value), - super::plan_tokens::rust_str_slice_expr(&claim.input_openings) + rust_str(&claim.claim_value) )) }) .collect::, EmitError>>()? @@ -1692,6 +1691,10 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); if self.role == Role::Verifier { let mut source = String::new(); for (index, batch) in self.batches.iter().enumerate() { + source.push_str(&emit_str_array( + &format!("STAGE6_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS"), + &batch.claim_operands, + )); source.push_str(&emit_usize_array( &format!("STAGE6_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"), &batch.round_schedule, @@ -1703,14 +1706,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); .enumerate() .map(|(index, batch)| { format!( - " Stage6SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE6_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", + " Stage6SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: STAGE6_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS, claim_label: {}, round_label: {}, round_schedule: STAGE6_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", rust_str(&batch.symbol), rust_str(&batch.stage), rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), - super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) ) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 2b6d774aa4..823145d5d3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1520,7 +1520,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); .iter() .map(|claim| { Ok(format!( - " Stage7SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {}, input_openings: {} }},", + " Stage7SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {} }},", rust_str(&claim.symbol), rust_str(&claim.stage), rust_str(&claim.domain), @@ -1533,8 +1533,7 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); &self.role, claim.relation.as_deref() )?, - rust_str(&claim.claim_value), - super::plan_tokens::rust_str_slice_expr(&claim.input_openings) + rust_str(&claim.claim_value) )) }) .collect::, EmitError>>()? @@ -1588,6 +1587,10 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); if self.role == Role::Verifier { let mut source = String::new(); for (index, batch) in self.batches.iter().enumerate() { + source.push_str(&emit_str_array( + &format!("STAGE7_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS"), + &batch.claim_operands, + )); source.push_str(&emit_usize_array( &format!("STAGE7_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"), &batch.round_schedule, @@ -1599,14 +1602,12 @@ super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); .enumerate() .map(|(index, batch)| { format!( - " Stage7SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE7_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", + " Stage7SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: STAGE7_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS, claim_label: {}, round_label: {}, round_schedule: STAGE7_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", rust_str(&batch.symbol), rust_str(&batch.stage), rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), - super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), rust_str(&batch.claim_label), rust_str(&batch.round_label) ) diff --git a/crates/bolt/src/protocols/jolt/verifier_common.rs.template b/crates/bolt/src/protocols/jolt/verifier_common.rs.template index 921096bd1e..6a73d0513b 100644 --- a/crates/bolt/src/protocols/jolt/verifier_common.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_common.rs.template @@ -177,7 +177,6 @@ pub struct SumcheckClaimPlan { pub kernel: Option<&'static str>, pub relation: Option, pub claim_value: &'static str, - pub input_openings: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -187,7 +186,6 @@ pub struct SumcheckBatchPlan { pub proof_slot: &'static str, pub policy: &'static str, pub count: usize, - pub ordered_claims: &'static [&'static str], pub claim_operands: &'static [&'static str], pub claim_label: &'static str, pub round_label: &'static str, diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 045d217222..f2d0b4aa67 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -58,7 +58,36 @@ macro_rules! stage_claim { kernel: $plan.kernel.as_deref().map(super::leak_str), relation: stage_optional_relation_kind!(generated, $plan.relation.as_deref()), claim_value: super::leak_str(&$plan.claim_value), - input_openings: super::leak_str_slice(&$plan.input_openings), + } + }; +} + +macro_rules! stage_sumcheck_batch { + (kernel, $module:ident, $batch:ident, $plan:ident) => { + $module::$batch { + symbol: super::leak_str(&$plan.symbol), + stage: super::leak_str(&$plan.stage), + proof_slot: super::leak_str(&$plan.proof_slot), + policy: super::leak_str(&$plan.policy), + count: $plan.count, + ordered_claims: super::leak_str_slice(&$plan.ordered_claims), + claim_operands: super::leak_str_slice(&$plan.claim_operands), + claim_label: super::leak_str(&$plan.claim_label), + round_label: super::leak_str(&$plan.round_label), + round_schedule: super::leak_usize_slice(&$plan.round_schedule), + } + }; + (generated, $module:ident, $batch:ident, $plan:ident) => { + $module::$batch { + symbol: super::leak_str(&$plan.symbol), + stage: super::leak_str(&$plan.stage), + proof_slot: super::leak_str(&$plan.proof_slot), + policy: super::leak_str(&$plan.policy), + count: $plan.count, + claim_operands: super::leak_str_slice(&$plan.claim_operands), + claim_label: super::leak_str(&$plan.claim_label), + round_label: super::leak_str(&$plan.round_label), + round_schedule: super::leak_usize_slice(&$plan.round_schedule), } }; } @@ -453,18 +482,7 @@ macro_rules! define_stage_adapter_impl { program .batches .iter() - .map(|plan| $module::$batch { - symbol: super::leak_str(&plan.symbol), - stage: super::leak_str(&plan.stage), - proof_slot: super::leak_str(&plan.proof_slot), - policy: super::leak_str(&plan.policy), - count: plan.count, - ordered_claims: super::leak_str_slice(&plan.ordered_claims), - claim_operands: super::leak_str_slice(&plan.claim_operands), - claim_label: super::leak_str(&plan.claim_label), - round_label: super::leak_str(&plan.round_label), - round_schedule: super::leak_usize_slice(&plan.round_schedule), - }) + .map(|plan| stage_sumcheck_batch!($mode, $module, $batch, plan)) .collect(), ), drivers: super::leak_slice( @@ -764,18 +782,7 @@ macro_rules! define_stage1_adapter { program .batches .iter() - .map(|plan| $module::$batch { - symbol: super::leak_str(&plan.symbol), - stage: super::leak_str(&plan.stage), - proof_slot: super::leak_str(&plan.proof_slot), - policy: super::leak_str(&plan.policy), - count: plan.count, - ordered_claims: super::leak_str_slice(&plan.ordered_claims), - claim_operands: super::leak_str_slice(&plan.claim_operands), - claim_label: super::leak_str(&plan.claim_label), - round_label: super::leak_str(&plan.round_label), - round_schedule: super::leak_usize_slice(&plan.round_schedule), - }) + .map(|plan| stage_sumcheck_batch!($mode, $module, $batch, plan)) .collect(), ), drivers: super::leak_slice( diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs index 921096bd1e..6a73d0513b 100644 --- a/crates/jolt-verifier/src/stages/common.rs +++ b/crates/jolt-verifier/src/stages/common.rs @@ -177,7 +177,6 @@ pub struct SumcheckClaimPlan { pub kernel: Option<&'static str>, pub relation: Option, pub claim_value: &'static str, - pub input_openings: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -187,7 +186,6 @@ pub struct SumcheckBatchPlan { pub proof_slot: &'static str, pub policy: &'static str, pub count: usize, - pub ordered_claims: &'static [&'static str], pub claim_operands: &'static [&'static str], pub claim_label: &'static str, pub round_label: &'static str, diff --git a/crates/jolt-verifier/src/stages/stage1_outer.rs b/crates/jolt-verifier/src/stages/stage1_outer.rs index 20b0e24ee3..d8aaf5b608 100644 --- a/crates/jolt-verifier/src/stages/stage1_outer.rs +++ b/crates/jolt-verifier/src/stages/stage1_outer.rs @@ -44,16 +44,16 @@ pub const STAGE1_TRANSCRIPT_SQUEEZES: &[Stage1TranscriptSqueezePlan] = &[ ]; pub const STAGE1_SUMCHECK_CLAIMS: &[Stage1SumcheckClaimPlan] = &[ - Stage1SumcheckClaimPlan { symbol: "stage1.uniskip.input", stage: "stage1", domain: "jolt.stage1_uniskip_domain", num_rounds: 1, degree: 27, claim: "stage1.zero", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterUniskip), claim_value: "stage1.zero", input_openings: &[] }, - Stage1SumcheckClaimPlan { symbol: "stage1.outer_remaining.input", stage: "stage1", domain: "jolt.trace_domain", num_rounds: 17, degree: 3, claim: "stage1.uniskip.eval", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterRemaining), claim_value: "stage1.uniskip.eval", input_openings: &["stage1.uniskip.opening"] }, + Stage1SumcheckClaimPlan { symbol: "stage1.uniskip.input", stage: "stage1", domain: "jolt.stage1_uniskip_domain", num_rounds: 1, degree: 27, claim: "stage1.zero", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterUniskip), claim_value: "stage1.zero" }, + Stage1SumcheckClaimPlan { symbol: "stage1.outer_remaining.input", stage: "stage1", domain: "jolt.trace_domain", num_rounds: 17, degree: 3, claim: "stage1.uniskip.eval", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterRemaining), claim_value: "stage1.uniskip.eval" }, ]; pub const STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1]; pub const STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[17]; pub const STAGE1_SUMCHECK_BATCHES: &[Stage1SumcheckBatchPlan] = &[ - Stage1SumcheckBatchPlan { symbol: "stage1.uniskip.batch", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: &["stage1.uniskip.input"], claim_operands: &["stage1.uniskip.input"], claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, - Stage1SumcheckBatchPlan { symbol: "stage1.outer_remaining.batch", stage: "stage1", proof_slot: "stage1.sumcheck", policy: "jolt_core_front_loaded", count: 1, ordered_claims: &["stage1.outer_remaining.input"], claim_operands: &["stage1.outer_remaining.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, + Stage1SumcheckBatchPlan { symbol: "stage1.uniskip.batch", stage: "stage1", proof_slot: "stage1.uni_skip_first_round", policy: "single_instance", count: 1, claim_operands: &["stage1.uniskip.input"], claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE1_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage1SumcheckBatchPlan { symbol: "stage1.outer_remaining.batch", stage: "stage1", proof_slot: "stage1.sumcheck", policy: "jolt_core_front_loaded", count: 1, claim_operands: &["stage1.outer_remaining.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE1_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, ]; pub const STAGE1_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1]; diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index ca4eedd7c9..46480478b1 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -135,20 +135,20 @@ pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.LeftInstructionInput", "stage2.instruction_lookup.term.RightInstructionInput"] }, ]; pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[ - Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr", input_openings: &["stage2.input.stage1.Product", "stage2.input.stage1.ShouldBranch", "stage2.input.stage1.ShouldJump"] }, - Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some(Stage2RelationKind::Stage2RamReadWrite), claim_value: "stage2.ram_read_write.claim_expr", input_openings: &["stage2.input.stage1.RamReadValue", "stage2.input.stage1.RamWriteValue"] }, - Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.remainder.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage2.product_virtual.uniskip.opening", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualRemainder), claim_value: "stage2.product_virtual.uniskip.eval.UnivariateSkip", input_openings: &["stage2.product_virtual.uniskip.opening.UnivariateSkip"] }, - Stage2SumcheckClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage2.instruction_lookup.weighted_operands", kernel: None, relation: Some(Stage2RelationKind::Stage2InstructionLookupClaimReduction), claim_value: "stage2.instruction_lookup.claim_reduction.claim_expr", input_openings: &["stage2.input.stage1.LookupOutput", "stage2.input.stage1.LeftLookupOperand", "stage2.input.stage1.RightLookupOperand", "stage2.input.stage1.LeftInstructionInput", "stage2.input.stage1.RightInstructionInput"] }, - Stage2SumcheckClaimPlan { symbol: "stage2.ram_raf.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 2, claim: "stage2.ram_raf.ram_address", kernel: None, relation: Some(Stage2RelationKind::Stage2RamRafEvaluation), claim_value: "stage2.input.stage1.RamAddress", input_openings: &["stage2.input.stage1.RamAddress"] }, - Stage2SumcheckClaimPlan { symbol: "stage2.ram_output.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 3, claim: "zero", kernel: None, relation: Some(Stage2RelationKind::Stage2RamOutputCheck), claim_value: "stage2.ram_output.zero", input_openings: &[] }, + Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr" }, + Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some(Stage2RelationKind::Stage2RamReadWrite), claim_value: "stage2.ram_read_write.claim_expr" }, + Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.remainder.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage2.product_virtual.uniskip.opening", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualRemainder), claim_value: "stage2.product_virtual.uniskip.eval.UnivariateSkip" }, + Stage2SumcheckClaimPlan { symbol: "stage2.instruction_lookup.claim_reduction.input", stage: "stage2", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage2.instruction_lookup.weighted_operands", kernel: None, relation: Some(Stage2RelationKind::Stage2InstructionLookupClaimReduction), claim_value: "stage2.instruction_lookup.claim_reduction.claim_expr" }, + Stage2SumcheckClaimPlan { symbol: "stage2.ram_raf.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 2, claim: "stage2.ram_raf.ram_address", kernel: None, relation: Some(Stage2RelationKind::Stage2RamRafEvaluation), claim_value: "stage2.input.stage1.RamAddress" }, + Stage2SumcheckClaimPlan { symbol: "stage2.ram_output.input", stage: "stage2", domain: "jolt.ram_address_domain", num_rounds: 16, degree: 3, claim: "zero", kernel: None, relation: Some(Stage2RelationKind::Stage2RamOutputCheck), claim_value: "stage2.ram_output.zero" }, ]; pub const STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[1]; pub const STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE: &[usize] = &[16, 16]; pub const STAGE2_SUMCHECK_BATCHES: &[Stage2SumcheckBatchPlan] = &[ - Stage2SumcheckBatchPlan { symbol: "stage2.product_virtual.uniskip.batch", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", policy: "single_instance", count: 1, ordered_claims: &["stage2.product_virtual.uniskip.input"], claim_operands: &["stage2.product_virtual.uniskip.input"], claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, - Stage2SumcheckBatchPlan { symbol: "stage2.batch", stage: "stage2", proof_slot: "stage2.sumcheck", policy: "jolt_core_stage2_aligned", count: 5, ordered_claims: &["stage2.ram_read_write.input", "stage2.product_virtual.remainder.input", "stage2.instruction_lookup.claim_reduction.input", "stage2.ram_raf.input", "stage2.ram_output.input"], claim_operands: &["stage2.ram_read_write.input", "stage2.product_virtual.remainder.input", "stage2.instruction_lookup.claim_reduction.input", "stage2.ram_raf.input", "stage2.ram_output.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, + Stage2SumcheckBatchPlan { symbol: "stage2.product_virtual.uniskip.batch", stage: "stage2", proof_slot: "stage2.product_virtual.uni_skip_first_round", policy: "single_instance", count: 1, claim_operands: &["stage2.product_virtual.uniskip.input"], claim_label: "uniskip_claim", round_label: "uniskip_poly", round_schedule: STAGE2_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage2SumcheckBatchPlan { symbol: "stage2.batch", stage: "stage2", proof_slot: "stage2.sumcheck", policy: "jolt_core_stage2_aligned", count: 5, claim_operands: &["stage2.ram_read_write.input", "stage2.product_virtual.remainder.input", "stage2.instruction_lookup.claim_reduction.input", "stage2.ram_raf.input", "stage2.ram_output.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE2_SUMCHECK_BATCH_1_ROUND_SCHEDULE }, ]; pub const STAGE2_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[1]; diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 822c8f0a15..fe0929f4a8 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -105,14 +105,14 @@ pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[ Stage3FieldExprPlan { symbol: "stage3.registers.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers.partial.RdWriteValueRs1Value", "stage3.registers.term.Rs2Value"] }, ]; pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[ - Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr", input_openings: &["stage3.input.stage1.NextUnexpandedPC", "stage3.input.stage1.NextPC", "stage3.input.stage1.NextIsVirtual", "stage3.input.stage1.NextIsFirstInSequence", "stage3.input.stage2.product_virtual.NextIsNoop"] }, - Stage3SumcheckClaimPlan { symbol: "stage3.instruction_input.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage3.instruction_input.weighted_inputs", kernel: None, relation: Some(Stage3RelationKind::Stage3InstructionInput), claim_value: "stage3.instruction_input.claim_expr", input_openings: &["stage3.input.stage2.product_virtual.RightInstructionInput", "stage3.input.stage2.product_virtual.LeftInstructionInput"] }, - Stage3SumcheckClaimPlan { symbol: "stage3.registers_claim_reduction.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.registers.weighted_register_values", kernel: None, relation: Some(Stage3RelationKind::Stage3RegistersClaimReduction), claim_value: "stage3.registers.claim_expr", input_openings: &["stage3.input.stage1.RdWriteValue", "stage3.input.stage1.Rs1Value", "stage3.input.stage1.Rs2Value"] }, + Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr" }, + Stage3SumcheckClaimPlan { symbol: "stage3.instruction_input.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage3.instruction_input.weighted_inputs", kernel: None, relation: Some(Stage3RelationKind::Stage3InstructionInput), claim_value: "stage3.instruction_input.claim_expr" }, + Stage3SumcheckClaimPlan { symbol: "stage3.registers_claim_reduction.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.registers.weighted_register_values", kernel: None, relation: Some(Stage3RelationKind::Stage3RegistersClaimReduction), claim_value: "stage3.registers.claim_expr" }, ]; pub const STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16]; pub const STAGE3_SUMCHECK_BATCHES: &[Stage3SumcheckBatchPlan] = &[ - Stage3SumcheckBatchPlan { symbol: "stage3.batch", stage: "stage3", proof_slot: "stage3.sumcheck", policy: "jolt_core_stage3_aligned", count: 3, ordered_claims: &["stage3.spartan_shift.input", "stage3.instruction_input.input", "stage3.registers_claim_reduction.input"], claim_operands: &["stage3.spartan_shift.input", "stage3.instruction_input.input", "stage3.registers_claim_reduction.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage3SumcheckBatchPlan { symbol: "stage3.batch", stage: "stage3", proof_slot: "stage3.sumcheck", policy: "jolt_core_stage3_aligned", count: 3, claim_operands: &["stage3.spartan_shift.input", "stage3.instruction_input.input", "stage3.registers_claim_reduction.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE3_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16]; diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 2bf9f37b0f..5972999a7b 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -100,13 +100,13 @@ pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[ ]; pub const STAGE4_SUMCHECK_CLAIMS: &[Stage4SumcheckClaimPlan] = &[ - Stage4SumcheckClaimPlan { symbol: "stage4.registers_read_write.input", stage: "stage4", domain: "jolt.stage4_registers_rw_domain", num_rounds: 23, degree: 3, claim: "stage4.registers_read_write.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RegistersReadWrite), claim_value: "stage4.registers_read_write.claim_expr", input_openings: &["stage4.input.stage3.registers.RdWriteValue", "stage4.input.stage3.registers.Rs1Value", "stage4.input.stage3.registers.Rs2Value"] }, - Stage4SumcheckClaimPlan { symbol: "stage4.ram_val_check.input", stage: "stage4", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage4.ram_val_check.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RamValCheck), claim_value: "stage4.ram_val_check.claim_expr", input_openings: &["stage4.input.stage2.RamVal", "stage4.input.stage2.RamValFinal", "stage4.input.initial_ram.RamValInit"] }, + Stage4SumcheckClaimPlan { symbol: "stage4.registers_read_write.input", stage: "stage4", domain: "jolt.stage4_registers_rw_domain", num_rounds: 23, degree: 3, claim: "stage4.registers_read_write.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RegistersReadWrite), claim_value: "stage4.registers_read_write.claim_expr" }, + Stage4SumcheckClaimPlan { symbol: "stage4.ram_val_check.input", stage: "stage4", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage4.ram_val_check.weighted_values", kernel: None, relation: Some(Stage4RelationKind::Stage4RamValCheck), claim_value: "stage4.ram_val_check.claim_expr" }, ]; pub const STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[16, 7]; pub const STAGE4_SUMCHECK_BATCHES: &[Stage4SumcheckBatchPlan] = &[ - Stage4SumcheckBatchPlan { symbol: "stage4.batch", stage: "stage4", proof_slot: "stage4.sumcheck", policy: "jolt_core_stage4_aligned", count: 2, ordered_claims: &["stage4.registers_read_write.input", "stage4.ram_val_check.input"], claim_operands: &["stage4.registers_read_write.input", "stage4.ram_val_check.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage4SumcheckBatchPlan { symbol: "stage4.batch", stage: "stage4", proof_slot: "stage4.sumcheck", policy: "jolt_core_stage4_aligned", count: 2, claim_operands: &["stage4.registers_read_write.input", "stage4.ram_val_check.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE4_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[16, 7]; diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 7813d89931..7e4f6a1d0f 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -101,14 +101,14 @@ pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[ ]; pub const STAGE5_SUMCHECK_CLAIMS: &[Stage5SumcheckClaimPlan] = &[ - Stage5SumcheckClaimPlan { symbol: "stage5.instruction_read_raf.input", stage: "stage5", domain: "jolt.stage5_instruction_read_raf_domain", num_rounds: 144, degree: 10, claim: "stage5.instruction_read_raf.weighted_lookup_values", kernel: None, relation: Some(Stage5RelationKind::Stage5InstructionReadRaf), claim_value: "stage5.instruction_read_raf.claim_expr", input_openings: &["stage5.input.stage2.instruction.LookupOutput", "stage5.input.stage2.instruction.LeftLookupOperand", "stage5.input.stage2.instruction.RightLookupOperand"] }, - Stage5SumcheckClaimPlan { symbol: "stage5.ram_ra_claim_reduction.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage5.ram_ra_claim_reduction.weighted_ram_ra", kernel: None, relation: Some(Stage5RelationKind::Stage5RamRaClaimReduction), claim_value: "stage5.ram_ra_claim_reduction.claim_expr", input_openings: &["stage5.input.stage2.ram_raf.RamRa", "stage5.input.stage2.ram_read_write.RamRa", "stage5.input.stage4.ram_val_check.RamRa"] }, - Stage5SumcheckClaimPlan { symbol: "stage5.registers_val_evaluation.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage5.registers_val_evaluation.registers_val", kernel: None, relation: Some(Stage5RelationKind::Stage5RegistersValEvaluation), claim_value: "stage5.input.stage4.registers.RegistersVal", input_openings: &["stage5.input.stage4.registers.RegistersVal"] }, + Stage5SumcheckClaimPlan { symbol: "stage5.instruction_read_raf.input", stage: "stage5", domain: "jolt.stage5_instruction_read_raf_domain", num_rounds: 144, degree: 10, claim: "stage5.instruction_read_raf.weighted_lookup_values", kernel: None, relation: Some(Stage5RelationKind::Stage5InstructionReadRaf), claim_value: "stage5.instruction_read_raf.claim_expr" }, + Stage5SumcheckClaimPlan { symbol: "stage5.ram_ra_claim_reduction.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage5.ram_ra_claim_reduction.weighted_ram_ra", kernel: None, relation: Some(Stage5RelationKind::Stage5RamRaClaimReduction), claim_value: "stage5.ram_ra_claim_reduction.claim_expr" }, + Stage5SumcheckClaimPlan { symbol: "stage5.registers_val_evaluation.input", stage: "stage5", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage5.registers_val_evaluation.registers_val", kernel: None, relation: Some(Stage5RelationKind::Stage5RegistersValEvaluation), claim_value: "stage5.input.stage4.registers.RegistersVal" }, ]; pub const STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[128, 16]; pub const STAGE5_SUMCHECK_BATCHES: &[Stage5SumcheckBatchPlan] = &[ - Stage5SumcheckBatchPlan { symbol: "stage5.batch", stage: "stage5", proof_slot: "stage5.sumcheck", policy: "jolt_core_stage5_aligned", count: 3, ordered_claims: &["stage5.instruction_read_raf.input", "stage5.ram_ra_claim_reduction.input", "stage5.registers_val_evaluation.input"], claim_operands: &["stage5.instruction_read_raf.input", "stage5.ram_ra_claim_reduction.input", "stage5.registers_val_evaluation.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage5SumcheckBatchPlan { symbol: "stage5.batch", stage: "stage5", proof_slot: "stage5.sumcheck", policy: "jolt_core_stage5_aligned", count: 3, claim_operands: &["stage5.instruction_read_raf.input", "stage5.ram_ra_claim_reduction.input", "stage5.registers_val_evaluation.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE5_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[128, 16]; diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 30fca1ee92..775e9ddc78 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -349,17 +349,26 @@ pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ ]; pub const STAGE6_SUMCHECK_CLAIMS: &[Stage6SumcheckClaimPlan] = &[ - Stage6SumcheckClaimPlan { symbol: "stage6.bytecode_read_raf.input", stage: "stage6", domain: "jolt.stage6_bytecode_read_raf_domain", num_rounds: 26, degree: 4, claim: "stage6.bytecode_read_raf.weighted_prior_stage_values", kernel: None, relation: Some(Stage6RelationKind::Stage6BytecodeReadRaf), claim_value: "stage6.bytecode_read_raf.claim_expr.partial76", input_openings: &["stage6.input.stage1.UnexpandedPC", "stage6.input.stage1.Imm", "stage6.input.stage1.OpFlagAddOperands", "stage6.input.stage1.OpFlagSubtractOperands", "stage6.input.stage1.OpFlagMultiplyOperands", "stage6.input.stage1.OpFlagLoad", "stage6.input.stage1.OpFlagStore", "stage6.input.stage1.OpFlagJump", "stage6.input.stage1.OpFlagWriteLookupOutputToRD", "stage6.input.stage1.OpFlagVirtualInstruction", "stage6.input.stage1.OpFlagAssert", "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC", "stage6.input.stage1.OpFlagAdvice", "stage6.input.stage1.OpFlagIsCompressed", "stage6.input.stage1.OpFlagIsFirstInSequence", "stage6.input.stage1.OpFlagIsLastInSequence", "stage6.input.stage2.OpFlagJump", "stage6.input.stage2.InstructionFlagBranch", "stage6.input.stage2.OpFlagWriteLookupOutputToRD", "stage6.input.stage2.OpFlagVirtualInstruction", "stage6.input.stage3.instruction_input.Imm", "stage6.input.stage3.spartan_shift.UnexpandedPC", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm", "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop", "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction", "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence", "stage6.input.stage4.RdWa", "stage6.input.stage4.Rs1Ra", "stage6.input.stage4.Rs2Ra", "stage6.input.stage5.registers_val_evaluation.RdWa", "stage6.input.stage5.InstructionRafFlag", "stage6.input.stage5.LookupTableFlag_0", "stage6.input.stage5.LookupTableFlag_1", "stage6.input.stage5.LookupTableFlag_2", "stage6.input.stage5.LookupTableFlag_3", "stage6.input.stage5.LookupTableFlag_4", "stage6.input.stage5.LookupTableFlag_5", "stage6.input.stage5.LookupTableFlag_6", "stage6.input.stage5.LookupTableFlag_7", "stage6.input.stage5.LookupTableFlag_8", "stage6.input.stage5.LookupTableFlag_9", "stage6.input.stage5.LookupTableFlag_10", "stage6.input.stage5.LookupTableFlag_11", "stage6.input.stage5.LookupTableFlag_12", "stage6.input.stage5.LookupTableFlag_13", "stage6.input.stage5.LookupTableFlag_14", "stage6.input.stage5.LookupTableFlag_15", "stage6.input.stage5.LookupTableFlag_16", "stage6.input.stage5.LookupTableFlag_17", "stage6.input.stage5.LookupTableFlag_18", "stage6.input.stage5.LookupTableFlag_19", "stage6.input.stage5.LookupTableFlag_20", "stage6.input.stage5.LookupTableFlag_21", "stage6.input.stage5.LookupTableFlag_22", "stage6.input.stage5.LookupTableFlag_23", "stage6.input.stage5.LookupTableFlag_24", "stage6.input.stage5.LookupTableFlag_25", "stage6.input.stage5.LookupTableFlag_26", "stage6.input.stage5.LookupTableFlag_27", "stage6.input.stage5.LookupTableFlag_28", "stage6.input.stage5.LookupTableFlag_29", "stage6.input.stage5.LookupTableFlag_30", "stage6.input.stage5.LookupTableFlag_31", "stage6.input.stage5.LookupTableFlag_32", "stage6.input.stage5.LookupTableFlag_33", "stage6.input.stage5.LookupTableFlag_34", "stage6.input.stage5.LookupTableFlag_35", "stage6.input.stage5.LookupTableFlag_36", "stage6.input.stage5.LookupTableFlag_37", "stage6.input.stage5.LookupTableFlag_38", "stage6.input.stage5.LookupTableFlag_39", "stage6.input.stage5.LookupTableFlag_40", "stage6.input.stage1.PC", "stage6.input.stage3.spartan_shift.PC"] }, - Stage6SumcheckClaimPlan { symbol: "stage6.booleanity.input", stage: "stage6", domain: "jolt.stage6_booleanity_domain", num_rounds: 20, degree: 3, claim: "stage6.booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6Booleanity), claim_value: "stage6.zero", input_openings: &[] }, - Stage6SumcheckClaimPlan { symbol: "stage6.hamming_booleanity.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage6.hamming_booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6HammingBooleanity), claim_value: "stage6.zero", input_openings: &["stage6.input.stage1.LookupOutput"] }, - Stage6SumcheckClaimPlan { symbol: "stage6.ram_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.ram_ra_virtual.weighted_ram_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6RamRaVirtual), claim_value: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", input_openings: &["stage6.input.stage5.ram_ra_claim_reduction.RamRa"] }, - Stage6SumcheckClaimPlan { symbol: "stage6.instruction_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.instruction_ra_virtual.weighted_instruction_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6InstructionRaVirtual), claim_value: "stage6.instruction_ra_virtual.claim_expr.partial6", input_openings: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.input.stage5.instruction_read_raf.InstructionRa_1", "stage6.input.stage5.instruction_read_raf.InstructionRa_2", "stage6.input.stage5.instruction_read_raf.InstructionRa_3", "stage6.input.stage5.instruction_read_raf.InstructionRa_4", "stage6.input.stage5.instruction_read_raf.InstructionRa_5", "stage6.input.stage5.instruction_read_raf.InstructionRa_6", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"] }, - Stage6SumcheckClaimPlan { symbol: "stage6.inc_claim_reduction.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage6.inc_claim_reduction.weighted_increments", kernel: None, relation: Some(Stage6RelationKind::Stage6IncClaimReduction), claim_value: "stage6.inc_claim_reduction.claim_expr.partial2", input_openings: &["stage6.input.stage2.ram_read_write.RamInc", "stage6.input.stage4.ram_val_check.RamInc", "stage6.input.stage4.registers_read_write.RdInc", "stage6.input.stage5.registers_val_evaluation.RdInc"] }, + Stage6SumcheckClaimPlan { symbol: "stage6.bytecode_read_raf.input", stage: "stage6", domain: "jolt.stage6_bytecode_read_raf_domain", num_rounds: 26, degree: 4, claim: "stage6.bytecode_read_raf.weighted_prior_stage_values", kernel: None, relation: Some(Stage6RelationKind::Stage6BytecodeReadRaf), claim_value: "stage6.bytecode_read_raf.claim_expr.partial76" }, + Stage6SumcheckClaimPlan { symbol: "stage6.booleanity.input", stage: "stage6", domain: "jolt.stage6_booleanity_domain", num_rounds: 20, degree: 3, claim: "stage6.booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6Booleanity), claim_value: "stage6.zero" }, + Stage6SumcheckClaimPlan { symbol: "stage6.hamming_booleanity.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 3, claim: "stage6.hamming_booleanity.zero", kernel: None, relation: Some(Stage6RelationKind::Stage6HammingBooleanity), claim_value: "stage6.zero" }, + Stage6SumcheckClaimPlan { symbol: "stage6.ram_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.ram_ra_virtual.weighted_ram_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6RamRaVirtual), claim_value: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" }, + Stage6SumcheckClaimPlan { symbol: "stage6.instruction_ra_virtual.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 5, claim: "stage6.instruction_ra_virtual.weighted_instruction_ra", kernel: None, relation: Some(Stage6RelationKind::Stage6InstructionRaVirtual), claim_value: "stage6.instruction_ra_virtual.claim_expr.partial6" }, + Stage6SumcheckClaimPlan { symbol: "stage6.inc_claim_reduction.input", stage: "stage6", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage6.inc_claim_reduction.weighted_increments", kernel: None, relation: Some(Stage6RelationKind::Stage6IncClaimReduction), claim_value: "stage6.inc_claim_reduction.claim_expr.partial2" }, ]; +pub const STAGE6_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &[ + "stage6.bytecode_read_raf.input", + "stage6.booleanity.input", + "stage6.hamming_booleanity.input", + "stage6.ram_ra_virtual.input", + "stage6.instruction_ra_virtual.input", + "stage6.inc_claim_reduction.input", +]; + pub const STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[10, 16]; pub const STAGE6_SUMCHECK_BATCHES: &[Stage6SumcheckBatchPlan] = &[ - Stage6SumcheckBatchPlan { symbol: "stage6.batch", stage: "stage6", proof_slot: "stage6.sumcheck", policy: "jolt_core_stage6_aligned", count: 6, ordered_claims: &["stage6.bytecode_read_raf.input", "stage6.booleanity.input", "stage6.hamming_booleanity.input", "stage6.ram_ra_virtual.input", "stage6.instruction_ra_virtual.input", "stage6.inc_claim_reduction.input"], claim_operands: &["stage6.bytecode_read_raf.input", "stage6.booleanity.input", "stage6.hamming_booleanity.input", "stage6.ram_ra_virtual.input", "stage6.instruction_ra_virtual.input", "stage6.inc_claim_reduction.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage6SumcheckBatchPlan { symbol: "stage6.batch", stage: "stage6", proof_slot: "stage6.sumcheck", policy: "jolt_core_stage6_aligned", count: 6, claim_operands: STAGE6_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE6_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[10, 16]; diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index fe1c504728..3d3c193144 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -208,12 +208,14 @@ pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ ]; pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[ - Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some(Stage7RelationKind::Stage7HammingWeightClaimReduction), claim_value: "stage7.hamming_weight_claim_reduction.claim_expr.partial115", input_openings: &["stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.booleanity.InstructionRa_0", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", "stage7.input.stage6.booleanity.InstructionRa_1", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", "stage7.input.stage6.booleanity.InstructionRa_2", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", "stage7.input.stage6.booleanity.InstructionRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", "stage7.input.stage6.booleanity.InstructionRa_4", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", "stage7.input.stage6.booleanity.InstructionRa_5", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", "stage7.input.stage6.booleanity.InstructionRa_6", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", "stage7.input.stage6.booleanity.InstructionRa_7", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", "stage7.input.stage6.booleanity.InstructionRa_8", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", "stage7.input.stage6.booleanity.InstructionRa_9", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", "stage7.input.stage6.booleanity.InstructionRa_10", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", "stage7.input.stage6.booleanity.InstructionRa_11", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", "stage7.input.stage6.booleanity.InstructionRa_12", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", "stage7.input.stage6.booleanity.InstructionRa_13", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", "stage7.input.stage6.booleanity.InstructionRa_14", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", "stage7.input.stage6.booleanity.InstructionRa_15", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", "stage7.input.stage6.booleanity.InstructionRa_16", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", "stage7.input.stage6.booleanity.InstructionRa_17", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", "stage7.input.stage6.booleanity.InstructionRa_18", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", "stage7.input.stage6.booleanity.InstructionRa_19", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", "stage7.input.stage6.booleanity.InstructionRa_20", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", "stage7.input.stage6.booleanity.InstructionRa_21", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", "stage7.input.stage6.booleanity.InstructionRa_22", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", "stage7.input.stage6.booleanity.InstructionRa_23", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", "stage7.input.stage6.booleanity.InstructionRa_24", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", "stage7.input.stage6.booleanity.InstructionRa_25", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", "stage7.input.stage6.booleanity.InstructionRa_26", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", "stage7.input.stage6.booleanity.InstructionRa_27", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", "stage7.input.stage6.booleanity.InstructionRa_28", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", "stage7.input.stage6.booleanity.InstructionRa_29", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", "stage7.input.stage6.booleanity.InstructionRa_30", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", "stage7.input.stage6.booleanity.InstructionRa_31", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", "stage7.input.stage6.booleanity.BytecodeRa_0", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", "stage7.input.stage6.booleanity.BytecodeRa_1", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", "stage7.input.stage6.booleanity.BytecodeRa_2", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", "stage7.input.stage6.booleanity.RamRa_0", "stage7.input.stage6.ram_ra_virtual.RamRa_0", "stage7.input.stage6.booleanity.RamRa_1", "stage7.input.stage6.ram_ra_virtual.RamRa_1", "stage7.input.stage6.booleanity.RamRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_2", "stage7.input.stage6.booleanity.RamRa_3", "stage7.input.stage6.ram_ra_virtual.RamRa_3"] }, + Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some(Stage7RelationKind::Stage7HammingWeightClaimReduction), claim_value: "stage7.hamming_weight_claim_reduction.claim_expr.partial115" }, ]; +pub const STAGE7_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &["stage7.hamming_weight_claim_reduction.input"]; + pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[ - Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, ordered_claims: &["stage7.hamming_weight_claim_reduction.input"], claim_operands: &["stage7.hamming_weight_claim_reduction.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, claim_operands: STAGE7_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4]; From f906dd28e385ae32fa7d672aedc05c6f0ef93455 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 21:12:26 -0600 Subject: [PATCH 014/171] refactor(bolt): split verifier runtime into Bolt + Jolt audit tiers Split the monolithic ~1.9k-LOC stages/common.rs into two files along an explicit audit boundary: Tier A (Bolt verifier runtime): stages/common.rs 1,265 LOC generic, protocol-agnostic plan structs, ValueStore, sumcheck driver loop, opening-equality interpreter, transcript helpers Tier B (audited Jolt verifier core): stages/jolt_relations.rs 638 LOC hand-written Jolt-specific verifier math: Stage 6/7 evaluators, normalize_*_point, bytecode_gamma_powers, Stage67Bytecode* glue, polynomial-evaluation primitives Tier B is the audit surface for Jolt-specific relation math; growth here is now reviewed as a protocol-math decision rather than emitter LOC creep. Tier A holds the generic Bolt scaffolding and is the long-term shrink target as more helpers move into typed plan data driven from MLIR. Wired through the artifact pipeline (verifier_runtime_modules now lists both `common` and `jolt_relations`) and updated stage4/5/6 emitters to split their import sites between super::common::{...} and super::jolt_relations::{...}. Per-tier hard LOC ceilings are enforced by verifier_cleanup.rs: BOLT_RUNTIME_BASELINE_LOC_CEILING = 1_400 (current 1,265) JOLT_VERIFIER_CORE_BASELINE_LOC_CEILING = 700 (current 638) GENERATED_VERIFIER_TARGET_LOC = 6_100 (current 6,002, bumped from 6,000 to absorb the import-split overhead) GOAL.md gains an "Audit Tiers" section describing the A/B/C split and records the post-split per-tier baseline. The pre-split "shared verifier runtime" framing is retired. cargo nextest -p bolt --test verifier_cleanup --test commitment_ir cargo clippy -p bolt --all-targets -- -D warnings cargo fmt --check all green. Co-authored-by: Cursor --- crates/bolt/GOAL.md | 63 +- crates/bolt/src/protocols/jolt/artifacts.rs | 28 +- .../src/protocols/jolt/emit/rust/stage4.rs | 3 +- .../src/protocols/jolt/emit/rust/stage5.rs | 3 +- .../src/protocols/jolt/emit/rust/stage6.rs | 3 +- .../jolt/verifier_common.rs.template | 605 +---------------- .../jolt/verifier_jolt_relations.rs.template | 638 ++++++++++++++++++ crates/bolt/tests/commitment_ir.rs | 43 +- crates/bolt/tests/verifier_cleanup.rs | 71 +- crates/jolt-verifier/src/stages/common.rs | 605 +---------------- .../src/stages/jolt_relations.rs | 638 ++++++++++++++++++ crates/jolt-verifier/src/stages/mod.rs | 1 + crates/jolt-verifier/src/stages/stage4.rs | 3 +- crates/jolt-verifier/src/stages/stage5.rs | 3 +- crates/jolt-verifier/src/stages/stage6.rs | 3 +- 15 files changed, 1454 insertions(+), 1256 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template create mode 100644 crates/jolt-verifier/src/stages/jolt_relations.rs diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index 390ccfbbc3..2b47765b64 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -23,16 +23,20 @@ stage6 + stage7: ~13.2k LOC verifier.rs: 649 LOC ``` -Current locked cleanup baseline: +Current locked cleanup baseline (post-S1 audit-tier split): ```text -generated jolt-verifier total: 7,755 LOC -generated verifier surface: 5,966 LOC -shared verifier runtime: 1,789 LOC -stage6 + stage7: 1,669 LOC -verifier.rs: 487 LOC +generated jolt-verifier total: 7,905 LOC +generated verifier surface: 6,002 LOC +tier A (Bolt verifier runtime): 1,265 LOC stages/common.rs +tier B (Jolt verifier core): 638 LOC stages/jolt_relations.rs +stage6 + stage7: 1,660 LOC +verifier.rs: 428 LOC ``` +The shared runtime is now split along an explicit audit boundary. See +"Audit Tiers" below. + Target: ```text @@ -40,13 +44,49 @@ generated verifier surface: <= 4k-6k LOC stretch generated surface: <= 2k-3k LOC verifier.rs orchestration: <= 350-500 LOC stage6 + stage7 generated surface: <= 2k-3k LOC -shared runtime/helpers: allowed when generic, named, and reviewed +tier A (Bolt verifier runtime): shrink toward <= 800 LOC as more helpers + become typed plan data driven from MLIR +tier B (Jolt verifier core): stable around current size; growth here is + a protocol-math decision, not emitter creep ``` The goal is to reduce the human-facing generated verifier surface by roughly an order of magnitude. Shared runtime code may exist, but it must be modular, boring to audit, and driven by explicit MLIR-derived plan data. +## Audit Tiers + +The verifier code is partitioned into three explicit audit tiers. The `Concrete +Gates` section enforces a per-tier LOC ceiling for each tier independently so +growth is attributed to the right trust boundary. + +- **Tier A (Bolt verifier runtime):** generic, protocol-agnostic helpers + (plan structs, `ValueStore`, sumcheck driver loop, opening-equality + interpreter, transcript helpers). Lives in + `crates/jolt-verifier/src/stages/common.rs`, generated from + `crates/bolt/src/protocols/jolt/verifier_common.rs.template`. Tier A should + ratchet *down* over time as more helpers move into typed plan data driven + from MLIR. + +- **Tier B (audited Jolt verifier core):** hand-written Jolt-specific verifier + math and relations (Stage 6/7 evaluators, `normalize_*_point`, + `bytecode_gamma_powers`, the `Stage67Bytecode*` glue, polynomial-evaluation + primitives). Lives in `crates/jolt-verifier/src/stages/jolt_relations.rs`, + generated from + `crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template`. Tier + B is the audit surface for Jolt-specific math; it is expected to stay + roughly its current size and any growth here must be reviewed as a + *protocol-math* decision, not emitter LOC. + +- **Tier C (generated declarative stage data + orchestration):** typed plans, + thin `verify_stageN` wrappers, and `verifier.rs`. This is everything else + under `crates/jolt-verifier/src/`. Tier C should be aggressively shrunk + toward the stretch target. + +This split was introduced by the S1 audit-tier refactor. The pre-split +"shared verifier runtime" framing (a single ~1.8k-LOC `common.rs` mixing +generic Bolt scaffolding and Jolt-specific math) is retired. + This verifier cleanup is coupled to the generic protocol cleanup in `GENERIC_PROTOCOL_GOAL.md`: shrinking the generated verifier should move generic mechanics into Bolt IR/typed plans and shared runtime, not into Jolt-specific @@ -407,10 +447,13 @@ generated verifier imports no forbidden crates ## Concrete Gates -Readability and LOC gates: +Readability and LOC gates (enforced by `crates/bolt/tests/verifier_cleanup.rs`): ```text total generated jolt-verifier LOC trends down +generated verifier surface (Tier C) <= 6.1k, target <= 6k, stretch <= 3k +tier A bolt verifier runtime <= 1.4k, ratcheting down +tier B audited Jolt verifier core <= 700 (growth requires protocol-math review) verifier.rs <= 500 LOC, stretch <= 350 stage6 + stage7 generated LOC <= 3k-5k, stretch <= 2k-3k no duplicate stage-local generic plan structs @@ -426,7 +469,9 @@ field-expression formula strings trend to zero LOC gates are guardrails, not the quality definition. A shorter verifier that hides semantics in opaque runtime code or compiler-only conventions fails this -goal. +goal. The Tier A and Tier B ceilings are independently enforced so cleanup +work cannot accidentally grow the audited Jolt math while shrinking generic +scaffolding (or vice versa). Security and boundary gates: diff --git a/crates/bolt/src/protocols/jolt/artifacts.rs b/crates/bolt/src/protocols/jolt/artifacts.rs index c69d77ccb0..d136a05f44 100644 --- a/crates/bolt/src/protocols/jolt/artifacts.rs +++ b/crates/bolt/src/protocols/jolt/artifacts.rs @@ -242,13 +242,29 @@ pub fn jolt_artifact_config() -> ProtocolArtifactConfig { commitment_type: RustTypeRef::new("jolt_dory::DoryCommitment"), prover_setup_type: RustTypeRef::new("jolt_dory::DoryProverSetup"), role_api_extension: Some(jolt_evaluation_role_api_extension()), - verifier_runtime_modules: vec![ProtocolRuntimeModule { - module_name: "common".to_owned(), - file: GeneratedFile { - path: "src/stages/common.rs".to_owned(), - source: include_str!("verifier_common.rs.template").to_owned(), + verifier_runtime_modules: vec![ + // Tier A: generic Bolt verifier scaffolding (typed plan + // structs, ValueStore, generic sumcheck verification, generic + // field-expr dispatch). See crates/bolt/GOAL.md "Audit Tiers". + ProtocolRuntimeModule { + module_name: "common".to_owned(), + file: GeneratedFile { + path: "src/stages/common.rs".to_owned(), + source: include_str!("verifier_common.rs.template").to_owned(), + }, }, - }], + // Tier B: audited Jolt verifier core (hand-written Stage 6/7 + // relation evaluators, point normalizations, and Jolt-specific + // field-math helpers). NOT generated. See crates/bolt/GOAL.md + // "Audit Tiers". + ProtocolRuntimeModule { + module_name: "jolt_relations".to_owned(), + file: GeneratedFile { + path: "src/stages/jolt_relations.rs".to_owned(), + source: include_str!("verifier_jolt_relations.rs.template").to_owned(), + }, + }, + ], verifier_named_eval_type: RustTypeRef::new("crate::stages::common::StageNamedEval"), verifier_sumcheck_output_type: RustTypeRef::new( "crate::stages::common::StageSumcheckOutput", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index fcb68cfcf3..6eb35a18dd 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -962,7 +962,8 @@ impl Stage4CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, lt_polynomial_eval, reverse_slice};\n\ + "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ + use super::jolt_relations::lt_polynomial_eval;\n\ use jolt_field::{Field, Fr};\n\ use jolt_poly::EqPolynomial;\n\ use jolt_sumcheck::SumcheckError;\n\ diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index f01831a571..fd0662502f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -963,7 +963,8 @@ impl Stage5CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, identity_polynomial_eval, indexed_evals_by_prefix_any, lt_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval, reverse_slice, suffix_point};\n\ + "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice, suffix_point};\n\ + use super::jolt_relations::{identity_polynomial_eval, lt_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval};\n\ use jolt_field::{Field, Fr, RingCore};\n\ use jolt_lookup_tables::LookupTableKind;\n\ use jolt_poly::EqPolynomial;\n\ diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 41711d9090..a913e7eaf7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -987,7 +987,8 @@ impl Stage6CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{batch_claims, expected_stage67_booleanity, expected_stage67_bytecode_read_raf, expected_stage67_hamming_booleanity, expected_stage67_inc_claim_reduction, expected_stage67_instruction_ra_virtual, expected_stage67_ram_ra_virtual, find_batch, find_plan, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols};\n\ + "use super::common::{batch_claims, find_batch, find_plan};\n\ + use super::jolt_relations::{expected_stage67_booleanity, expected_stage67_bytecode_read_raf, expected_stage67_hamming_booleanity, expected_stage67_inc_claim_reduction, expected_stage67_instruction_ra_virtual, expected_stage67_ram_ra_virtual, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" diff --git a/crates/bolt/src/protocols/jolt/verifier_common.rs.template b/crates/bolt/src/protocols/jolt/verifier_common.rs.template index 6a73d0513b..a5883c82ee 100644 --- a/crates/bolt/src/protocols/jolt/verifier_common.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_common.rs.template @@ -6,8 +6,8 @@ use std::fmt; use std::marker::PhantomData; -use jolt_field::{Field, Fr, MulPow2, RingCore}; -use jolt_poly::{lagrange::lagrange_evals, EqPolynomial}; +use jolt_field::{Field, Fr, MulPow2}; +use jolt_poly::lagrange::lagrange_evals; use jolt_sumcheck::{ CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier, }; @@ -1127,14 +1127,6 @@ pub fn evaluate_field_expr( } } -pub fn bytecode_gamma_powers(gamma: Fr) -> [Fr; 8] { - let mut powers = [Fr::from_u64(1); 8]; - for index in 1..powers.len() { - powers[index] = powers[index - 1] * gamma; - } - powers -} - pub fn indexed_boolean_eq(index: usize, point: &[Fr]) -> Fr { point .iter() @@ -1189,103 +1181,6 @@ pub fn suffix_point<'a, F: Field>( }) } -pub fn normalize_bytecode_read_raf_point( - point: &[F], - log_t: usize, - input: &'static str, -) -> Result, RuntimePlanError> { - let log_k = point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input, - expected: log_t, - actual: point.len(), - })?; - let mut normalized = point.to_vec(); - normalized[..log_k].reverse(); - normalized[log_k..].reverse(); - Ok(normalized) -} - -pub fn normalize_instruction_read_raf_point( - point: &[F], - input: &'static str, -) -> Result, RuntimePlanError> { - const LOG_K: usize = 128; - if point.len() < LOG_K { - return Err(RuntimePlanError::InvalidInputLength { - input, - expected: LOG_K, - actual: point.len(), - }); - } - let mut normalized = point.to_vec(); - normalized[LOG_K..].reverse(); - Ok(normalized) -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage67RelationSymbols { - pub hamming_booleanity_instance: &'static str, - pub booleanity_point: &'static str, - pub stage5_instruction_ra0: &'static str, - pub booleanity_combined_point: &'static str, - pub booleanity_gamma: &'static str, - pub booleanity_instruction_ra_prefix: &'static str, - pub booleanity_bytecode_ra_prefix: &'static str, - pub booleanity_ram_ra_prefix: &'static str, - pub hamming_weight_eval: &'static str, - pub hamming_lookup_output: &'static str, - pub ram_ra_virtual_cycle: &'static str, - pub ram_ra_virtual_eval_prefix: &'static str, - pub instruction_ra_virtual_cycle: &'static str, - pub instruction_ra_virtual_eval_prefix: &'static str, - pub instruction_ra_virtual_input_prefix: &'static str, - pub instruction_ra_virtual_gamma: &'static str, - pub inc_ram_stage2: &'static str, - pub inc_ram_stage4: &'static str, - pub inc_rd_stage4: &'static str, - pub inc_rd_stage5: &'static str, - pub inc_gamma: &'static str, - pub inc_ram_eval: &'static str, - pub inc_rd_eval: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage67BytecodeSymbols { - pub point: &'static str, - pub gamma: &'static str, - pub bytecode_ra_eval_prefix: &'static str, - pub entries: &'static str, - pub entry_bytecode_index: &'static str, - pub stage_gammas: [&'static str; 5], - pub stage_cycle_points: [&'static str; 5], - pub stage4_register_point: &'static str, - pub stage5_register_point: &'static str, - pub entry_rd: &'static str, - pub entry_rs1: &'static str, - pub entry_rs2: &'static str, - pub entry_lookup_table: &'static str, -} - -pub trait Stage67BytecodeEntry { - fn address(&self) -> Fr; - fn imm(&self) -> Fr; - fn circuit_flags(&self) -> &[bool; 14]; - fn rd(&self) -> Option; - fn rs1(&self) -> Option; - fn rs2(&self) -> Option; - fn lookup_table(&self) -> Option; - fn is_interleaved(&self) -> bool; - fn is_branch(&self) -> bool; - fn left_is_rs1(&self) -> bool; - fn left_is_pc(&self) -> bool; - fn right_is_rs2(&self) -> bool; - fn right_is_imm(&self) -> bool; - fn is_noop(&self) -> bool; -} - pub fn store_scalar(store: &ValueStore, symbol: &'static str) -> Result { store.scalar_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol }) } @@ -1297,492 +1192,6 @@ pub fn store_point<'a>( store.point_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol }) } -pub fn stage67_trace_rounds( - instance_results: &[SumcheckInstanceResultPlan], - symbols: &Stage67RelationSymbols, -) -> Result { - instance_results - .iter() - .find(|instance| instance.relation == RelationKind::Stage6HammingBooleanity) - .map(|instance| instance.num_rounds) - .ok_or(RuntimePlanError::MissingValue { - symbol: symbols.hamming_booleanity_instance, - }) -} - -pub fn expected_stage67_bytecode_read_raf( - entries: &[E], - entry_bytecode_index: usize, - num_lookup_tables: usize, - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - log_t: usize, - symbols: &Stage67BytecodeSymbols, -) -> Result { - let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, symbols.point)?; - let log_k = opening_point.len() - log_t; - let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k); - - let gamma = store_scalar(store, symbols.gamma)?; - let gamma_powers = bytecode_gamma_powers(gamma); - let int_eval = identity_polynomial_eval(r_address_prime); - let stage_value_evals = stage67_bytecode_stage_value_evals( - entries, - entry_bytecode_index, - num_lookup_tables, - store, - r_address_prime, - r_cycle_prime.len(), - symbols, - )?; - let stage_cycle_points = - stage67_bytecode_stage_cycle_points(store, r_cycle_prime.len(), symbols)?; - let int_contrib = [ - gamma_powers[5] * int_eval, - Fr::from_u64(0), - gamma_powers[4] * int_eval, - Fr::from_u64(0), - Fr::from_u64(0), - ]; - - let mut val = Fr::from_u64(0); - for index in 0..stage_value_evals.len() { - val += (stage_value_evals[index] + int_contrib[index]) - * EqPolynomial::::mle(&stage_cycle_points[index], r_cycle_prime) - * gamma_powers[index]; - } - - let entry_bits = (0..log_k) - .map(|index| Fr::from_u64(((entry_bytecode_index >> (log_k - 1 - index)) & 1) as u64)) - .collect::>(); - let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; - let entry_contrib = gamma_powers[7] - * EqPolynomial::::mle(&entry_bits, r_address_prime) - * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); - let bytecode_ra = indexed_evals_by_prefix_any(evals, symbols.bytecode_ra_eval_prefix)? - .into_iter() - .product::(); - Ok((val + entry_contrib) * bytecode_ra) -} - -pub fn expected_stage67_booleanity( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - log_t: usize, - symbols: &Stage67RelationSymbols, -) -> Result { - let log_k_chunk = - local_point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.booleanity_point, - expected: log_t, - actual: local_point.len(), - })?; - let stage5_point = store_point(store, symbols.stage5_instruction_ra0)?; - let stage5_address_len = - stage5_point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.stage5_instruction_ra0, - expected: log_t, - actual: stage5_point.len(), - })?; - if stage5_address_len < log_k_chunk { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.stage5_instruction_ra0, - expected: log_k_chunk + log_t, - actual: stage5_point.len(), - }); - } - - let mut stage5_addr = stage5_point[..stage5_address_len].to_vec(); - stage5_addr.reverse(); - let mut combined_r = stage5_addr[stage5_address_len - log_k_chunk..].to_vec(); - combined_r.extend(stage5_point[stage5_address_len..].iter().rev().copied()); - if combined_r.len() != local_point.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.booleanity_combined_point, - expected: local_point.len(), - actual: combined_r.len(), - }); - } - let mut verifier_point = combined_r[..log_k_chunk].to_vec(); - verifier_point.reverse(); - verifier_point.extend(combined_r[log_k_chunk..].iter().rev().copied()); - let eq_eval = EqPolynomial::::mle(local_point, &verifier_point); - - let gamma = store_scalar(store, symbols.booleanity_gamma)?; - let gamma_sq = gamma.square(); - let mut gamma_power = Fr::from_u64(1); - let mut booleanity = Fr::from_u64(0); - for ra in stage67_booleanity_evals(evals, symbols)? { - booleanity += gamma_power * (ra.square() - ra); - gamma_power *= gamma_sq; - } - Ok(eq_eval * booleanity) -} - -pub fn expected_stage67_hamming_booleanity( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let hamming = eval_by_name(evals, symbols.hamming_weight_eval)?; - let lookup_output_point = reverse_slice(store_point(store, symbols.hamming_lookup_output)?); - if lookup_output_point.len() != local_point.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.hamming_lookup_output, - expected: local_point.len(), - actual: lookup_output_point.len(), - }); - } - let eq_eval = EqPolynomial::::mle(local_point, &lookup_output_point); - Ok((hamming.square() - hamming) * eq_eval) -} - -pub fn expected_stage67_ram_ra_virtual( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let r_cycle = suffix_point( - store_point(store, symbols.ram_ra_virtual_cycle)?, - r_cycle_reduced.len(), - symbols.ram_ra_virtual_cycle, - )?; - let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); - let ram_ra = indexed_evals_by_prefix_any(evals, symbols.ram_ra_virtual_eval_prefix)? - .into_iter() - .product::(); - Ok(eq_eval * ram_ra) -} - -pub fn expected_stage67_instruction_ra_virtual( - opening_inputs: &[OpeningInputPlan], - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let r_cycle = suffix_point( - store_point(store, symbols.instruction_ra_virtual_cycle)?, - r_cycle_reduced.len(), - symbols.instruction_ra_virtual_cycle, - )?; - let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); - let committed_ra = - indexed_evals_by_prefix_any(evals, symbols.instruction_ra_virtual_eval_prefix)?; - let virtual_count = opening_inputs - .iter() - .filter(|input| { - input - .symbol - .starts_with(symbols.instruction_ra_virtual_input_prefix) - }) - .count(); - if virtual_count == 0 || committed_ra.len() % virtual_count != 0 { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.instruction_ra_virtual_eval_prefix, - expected: virtual_count, - actual: committed_ra.len(), - }); - } - let committed_per_virtual = committed_ra.len() / virtual_count; - let gamma = store_scalar(store, symbols.instruction_ra_virtual_gamma)?; - let mut gamma_power = Fr::from_u64(1); - let mut value = Fr::from_u64(0); - for chunk in committed_ra.chunks(committed_per_virtual) { - value += gamma_power * chunk.iter().copied().product::(); - gamma_power *= gamma; - } - Ok(eq_eval * value) -} - -pub fn expected_stage67_inc_claim_reduction( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let ram_inc_stage2 = suffix_point( - store_point(store, symbols.inc_ram_stage2)?, - r_cycle_reduced.len(), - symbols.inc_ram_stage2, - )?; - let ram_inc_stage4 = suffix_point( - store_point(store, symbols.inc_ram_stage4)?, - r_cycle_reduced.len(), - symbols.inc_ram_stage4, - )?; - let rd_inc_stage4 = suffix_point( - store_point(store, symbols.inc_rd_stage4)?, - r_cycle_reduced.len(), - symbols.inc_rd_stage4, - )?; - let rd_inc_stage5 = suffix_point( - store_point(store, symbols.inc_rd_stage5)?, - r_cycle_reduced.len(), - symbols.inc_rd_stage5, - )?; - let gamma = store_scalar(store, symbols.inc_gamma)?; - let eq_ram_combined = EqPolynomial::::mle(ram_inc_stage2, &r_cycle_reduced) - + gamma * EqPolynomial::::mle(ram_inc_stage4, &r_cycle_reduced); - let eq_rd_combined = EqPolynomial::::mle(rd_inc_stage4, &r_cycle_reduced) - + gamma * EqPolynomial::::mle(rd_inc_stage5, &r_cycle_reduced); - let ram_inc = eval_by_name(evals, symbols.inc_ram_eval)?; - let rd_inc = eval_by_name(evals, symbols.inc_rd_eval)?; - Ok(ram_inc * eq_ram_combined + gamma.square() * rd_inc * eq_rd_combined) -} - -fn stage67_booleanity_evals( - evals: &[StageNamedEval], - symbols: &Stage67RelationSymbols, -) -> Result, RuntimePlanError> { - let mut values = indexed_evals_by_prefix_any(evals, symbols.booleanity_instruction_ra_prefix)?; - values.extend(indexed_evals_by_prefix_any( - evals, - symbols.booleanity_bytecode_ra_prefix, - )?); - values.extend(indexed_evals_by_prefix_any( - evals, - symbols.booleanity_ram_ra_prefix, - )?); - Ok(values) -} - -fn stage67_bytecode_stage_cycle_points( - store: &ValueStore, - log_t: usize, - symbols: &Stage67BytecodeSymbols, -) -> Result<[Vec; 5], RuntimePlanError> { - let point = |index| { - let symbol = symbols.stage_cycle_points[index]; - suffix_point(store_point(store, symbol)?, log_t, symbol).map(|point| point.to_vec()) - }; - Ok([point(0)?, point(1)?, point(2)?, point(3)?, point(4)?]) -} - -fn stage67_bytecode_stage_value_evals( - entries: &[E], - entry_bytecode_index: usize, - num_lookup_tables: usize, - store: &ValueStore, - r_address: &[Fr], - log_t: usize, - symbols: &Stage67BytecodeSymbols, -) -> Result<[Fr; 5], RuntimePlanError> { - let expected_len = - 1usize - .checked_shl(r_address.len() as u32) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.entries, - expected: usize::BITS as usize, - actual: r_address.len(), - })?; - if entries.len() != expected_len { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entries, - expected: expected_len, - actual: entries.len(), - }); - } - if entry_bytecode_index >= expected_len { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entry_bytecode_index, - expected: expected_len, - actual: entry_bytecode_index + 1, - }); - } - - let stage1_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[0])?, 16); - let stage2_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[1])?, 4); - let stage3_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[2])?, 9); - let stage4_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[3])?, 3); - let stage5_gamma_powers = field_powers( - store_scalar(store, symbols.stage_gammas[4])?, - num_lookup_tables + 2, - ); - - let stage4_register_point = - stage67_register_prefix_point(store, symbols.stage4_register_point, log_t)?; - let stage5_register_point = - stage67_register_prefix_point(store, symbols.stage5_register_point, log_t)?; - - let mut evals = [Fr::from_u64(0); 5]; - for (index, entry) in entries.iter().enumerate() { - let eq = indexed_boolean_eq(index, r_address); - let values = stage67_bytecode_entry_stage_values( - entry, - num_lookup_tables, - stage4_register_point, - stage5_register_point, - &stage1_gamma_powers, - &stage2_gamma_powers, - &stage3_gamma_powers, - &stage4_gamma_powers, - &stage5_gamma_powers, - symbols, - )?; - for stage in 0..evals.len() { - evals[stage] += eq * values[stage]; - } - } - Ok(evals) -} - -fn stage67_bytecode_entry_stage_values( - entry: &E, - num_lookup_tables: usize, - stage4_register_point: &[Fr], - stage5_register_point: &[Fr], - stage1_gamma_powers: &[Fr], - stage2_gamma_powers: &[Fr], - stage3_gamma_powers: &[Fr], - stage4_gamma_powers: &[Fr], - stage5_gamma_powers: &[Fr], - symbols: &Stage67BytecodeSymbols, -) -> Result<[Fr; 5], RuntimePlanError> { - let flags = entry.circuit_flags(); - let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1]; - for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) { - if *flag { - stage1 += *gamma; - } - } - - let mut stage2 = Fr::from_u64(0); - if flags[5] { - stage2 += stage2_gamma_powers[0]; - } - if entry.is_branch() { - stage2 += stage2_gamma_powers[1]; - } - if flags[6] { - stage2 += stage2_gamma_powers[2]; - } - if flags[7] { - stage2 += stage2_gamma_powers[3]; - } - - let mut stage3 = entry.imm() + entry.address() * stage3_gamma_powers[1]; - if entry.left_is_rs1() { - stage3 += stage3_gamma_powers[2]; - } - if entry.left_is_pc() { - stage3 += stage3_gamma_powers[3]; - } - if entry.right_is_rs2() { - stage3 += stage3_gamma_powers[4]; - } - if entry.right_is_imm() { - stage3 += stage3_gamma_powers[5]; - } - if entry.is_noop() { - stage3 += stage3_gamma_powers[6]; - } - if flags[7] { - stage3 += stage3_gamma_powers[7]; - } - if flags[12] { - stage3 += stage3_gamma_powers[8]; - } - - let stage4 = stage67_register_eq(entry.rd(), stage4_register_point, symbols.entry_rd)? - * stage4_gamma_powers[0] - + stage67_register_eq(entry.rs1(), stage4_register_point, symbols.entry_rs1)? - * stage4_gamma_powers[1] - + stage67_register_eq(entry.rs2(), stage4_register_point, symbols.entry_rs2)? - * stage4_gamma_powers[2]; - - let mut stage5 = stage67_register_eq(entry.rd(), stage5_register_point, symbols.entry_rd)? - * stage5_gamma_powers[0]; - if !entry.is_interleaved() { - stage5 += stage5_gamma_powers[1]; - } - if let Some(table) = entry.lookup_table() { - if table >= num_lookup_tables { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entry_lookup_table, - expected: num_lookup_tables, - actual: table + 1, - }); - } - stage5 += stage5_gamma_powers[2 + table]; - } - - Ok([stage1, stage2, stage3, stage4, stage5]) -} - -fn stage67_register_eq( - index: Option, - point: &[Fr], - input: &'static str, -) -> Result { - let Some(index) = index else { - return Ok(Fr::from_u64(0)); - }; - let register_count = - 1usize - .checked_shl(point.len() as u32) - .ok_or(RuntimePlanError::InvalidInputLength { - input, - expected: usize::BITS as usize, - actual: point.len(), - })?; - if index >= register_count { - return Err(RuntimePlanError::InvalidInputLength { - input, - expected: register_count, - actual: index + 1, - }); - } - Ok(indexed_boolean_eq(index, point)) -} - -fn stage67_register_prefix_point<'a>( - store: &'a ValueStore, - symbol: &'static str, - log_t: usize, -) -> Result<&'a [Fr], RuntimePlanError> { - let point = store_point(store, symbol)?; - let register_len = - point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbol, - expected: log_t, - actual: point.len(), - })?; - prefix_point(point, register_len, symbol) -} - -pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Fr { - let stride_offset = usize::from(!left); - let operand_bits = point.len() / 2; - (0..operand_bits) - .map(|index| point[2 * index + stride_offset].mul_pow_2(operand_bits - 1 - index)) - .sum() -} - -pub fn identity_polynomial_eval(point: &[Fr]) -> Fr { - point - .iter() - .enumerate() - .map(|(index, value)| value.mul_pow_2(point.len() - 1 - index)) - .sum() -} - pub fn append_labeled_scalar(transcript: &mut T, label: &'static str, scalar: &Fr) where T: Transcript, @@ -1838,16 +1247,6 @@ where Ok(()) } -pub fn lt_polynomial_eval(x: &[Fr], y: &[Fr]) -> Fr { - let mut lt_eval = Fr::from_u64(0); - let mut eq_term = Fr::from_u64(1); - for (x_i, y_i) in x.iter().zip(y.iter()) { - lt_eval += (Fr::from_u64(1) - *x_i) * *y_i * eq_term; - eq_term *= Fr::from_u64(1) - *x_i - *y_i + *x_i * *y_i + *x_i * *y_i; - } - lt_eval -} - pub fn pow_field(base: F, mut exponent: usize) -> F { let mut result = F::one(); let mut power = base; diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template new file mode 100644 index 0000000000..f812297135 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -0,0 +1,638 @@ +#![expect( + clippy::too_many_arguments, + reason = "Stage 6/7 verifier relation helpers thread typed plan symbols and store/eval slices through their argument lists" +)] + +//! Tier B: Audited Jolt verifier core. +//! +//! This module is **not** generic Bolt scaffolding. It is the hand-written +//! Jolt-specific verifier math that the Bolt compiler does not yet lower +//! from MLIR. It includes: +//! +//! - point normalizations for the Jolt bytecode and instruction RA +//! read-RAF lookup arguments +//! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement +//! - the `expected_stage67_*` relation evaluators for Stage 6/7 booleanity, +//! bytecode-read-RAF, hamming booleanity, RAM RA virtual, +//! instruction RA virtual, and inc-claim-reduction relations +//! - the small Jolt-specific field-math helpers +//! (`operand_polynomial_eval`, `identity_polynomial_eval`, +//! `lt_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt +//! verification +//! +//! Treat changes here as Jolt protocol changes, not as compiler-output +//! cleanups. Generic Bolt verifier scaffolding (typed plan structs, +//! `ValueStore`, generic sumcheck verification, generic field-expr +//! dispatch) lives in `super::common` instead. +//! +//! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition. + +use jolt_field::{Field, Fr, MulPow2, RingCore}; +use jolt_poly::EqPolynomial; + +use super::common::{ + eval_by_name, field_powers, indexed_boolean_eq, indexed_evals_by_prefix_any, prefix_point, + reverse_slice, store_point, store_scalar, suffix_point, OpeningInputPlan, RelationKind, + RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, +}; + +pub fn bytecode_gamma_powers(gamma: Fr) -> [Fr; 8] { + let mut powers = [Fr::from_u64(1); 8]; + for index in 1..powers.len() { + powers[index] = powers[index - 1] * gamma; + } + powers +} + +pub fn normalize_bytecode_read_raf_point( + point: &[F], + log_t: usize, + input: &'static str, +) -> Result, RuntimePlanError> { + let log_k = point + .len() + .checked_sub(log_t) + .ok_or(RuntimePlanError::InvalidInputLength { + input, + expected: log_t, + actual: point.len(), + })?; + let mut normalized = point.to_vec(); + normalized[..log_k].reverse(); + normalized[log_k..].reverse(); + Ok(normalized) +} + +pub fn normalize_instruction_read_raf_point( + point: &[F], + input: &'static str, +) -> Result, RuntimePlanError> { + const LOG_K: usize = 128; + if point.len() < LOG_K { + return Err(RuntimePlanError::InvalidInputLength { + input, + expected: LOG_K, + actual: point.len(), + }); + } + let mut normalized = point.to_vec(); + normalized[LOG_K..].reverse(); + Ok(normalized) +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage67RelationSymbols { + pub hamming_booleanity_instance: &'static str, + pub booleanity_point: &'static str, + pub stage5_instruction_ra0: &'static str, + pub booleanity_combined_point: &'static str, + pub booleanity_gamma: &'static str, + pub booleanity_instruction_ra_prefix: &'static str, + pub booleanity_bytecode_ra_prefix: &'static str, + pub booleanity_ram_ra_prefix: &'static str, + pub hamming_weight_eval: &'static str, + pub hamming_lookup_output: &'static str, + pub ram_ra_virtual_cycle: &'static str, + pub ram_ra_virtual_eval_prefix: &'static str, + pub instruction_ra_virtual_cycle: &'static str, + pub instruction_ra_virtual_eval_prefix: &'static str, + pub instruction_ra_virtual_input_prefix: &'static str, + pub instruction_ra_virtual_gamma: &'static str, + pub inc_ram_stage2: &'static str, + pub inc_ram_stage4: &'static str, + pub inc_rd_stage4: &'static str, + pub inc_rd_stage5: &'static str, + pub inc_gamma: &'static str, + pub inc_ram_eval: &'static str, + pub inc_rd_eval: &'static str, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage67BytecodeSymbols { + pub point: &'static str, + pub gamma: &'static str, + pub bytecode_ra_eval_prefix: &'static str, + pub entries: &'static str, + pub entry_bytecode_index: &'static str, + pub stage_gammas: [&'static str; 5], + pub stage_cycle_points: [&'static str; 5], + pub stage4_register_point: &'static str, + pub stage5_register_point: &'static str, + pub entry_rd: &'static str, + pub entry_rs1: &'static str, + pub entry_rs2: &'static str, + pub entry_lookup_table: &'static str, +} + +pub trait Stage67BytecodeEntry { + fn address(&self) -> Fr; + fn imm(&self) -> Fr; + fn circuit_flags(&self) -> &[bool; 14]; + fn rd(&self) -> Option; + fn rs1(&self) -> Option; + fn rs2(&self) -> Option; + fn lookup_table(&self) -> Option; + fn is_interleaved(&self) -> bool; + fn is_branch(&self) -> bool; + fn left_is_rs1(&self) -> bool; + fn left_is_pc(&self) -> bool; + fn right_is_rs2(&self) -> bool; + fn right_is_imm(&self) -> bool; + fn is_noop(&self) -> bool; +} + +pub fn stage67_trace_rounds( + instance_results: &[SumcheckInstanceResultPlan], + symbols: &Stage67RelationSymbols, +) -> Result { + instance_results + .iter() + .find(|instance| instance.relation == RelationKind::Stage6HammingBooleanity) + .map(|instance| instance.num_rounds) + .ok_or(RuntimePlanError::MissingValue { + symbol: symbols.hamming_booleanity_instance, + }) +} + +pub fn expected_stage67_bytecode_read_raf( + entries: &[E], + entry_bytecode_index: usize, + num_lookup_tables: usize, + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + log_t: usize, + symbols: &Stage67BytecodeSymbols, +) -> Result { + let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, symbols.point)?; + let log_k = opening_point.len() - log_t; + let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k); + + let gamma = store_scalar(store, symbols.gamma)?; + let gamma_powers = bytecode_gamma_powers(gamma); + let int_eval = identity_polynomial_eval(r_address_prime); + let stage_value_evals = stage67_bytecode_stage_value_evals( + entries, + entry_bytecode_index, + num_lookup_tables, + store, + r_address_prime, + r_cycle_prime.len(), + symbols, + )?; + let stage_cycle_points = + stage67_bytecode_stage_cycle_points(store, r_cycle_prime.len(), symbols)?; + let int_contrib = [ + gamma_powers[5] * int_eval, + Fr::from_u64(0), + gamma_powers[4] * int_eval, + Fr::from_u64(0), + Fr::from_u64(0), + ]; + + let mut val = Fr::from_u64(0); + for index in 0..stage_value_evals.len() { + val += (stage_value_evals[index] + int_contrib[index]) + * EqPolynomial::::mle(&stage_cycle_points[index], r_cycle_prime) + * gamma_powers[index]; + } + + let entry_bits = (0..log_k) + .map(|index| Fr::from_u64(((entry_bytecode_index >> (log_k - 1 - index)) & 1) as u64)) + .collect::>(); + let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; + let entry_contrib = gamma_powers[7] + * EqPolynomial::::mle(&entry_bits, r_address_prime) + * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); + let bytecode_ra = indexed_evals_by_prefix_any(evals, symbols.bytecode_ra_eval_prefix)? + .into_iter() + .product::(); + Ok((val + entry_contrib) * bytecode_ra) +} + +pub fn expected_stage67_booleanity( + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + log_t: usize, + symbols: &Stage67RelationSymbols, +) -> Result { + let log_k_chunk = + local_point + .len() + .checked_sub(log_t) + .ok_or(RuntimePlanError::InvalidInputLength { + input: symbols.booleanity_point, + expected: log_t, + actual: local_point.len(), + })?; + let stage5_point = store_point(store, symbols.stage5_instruction_ra0)?; + let stage5_address_len = + stage5_point + .len() + .checked_sub(log_t) + .ok_or(RuntimePlanError::InvalidInputLength { + input: symbols.stage5_instruction_ra0, + expected: log_t, + actual: stage5_point.len(), + })?; + if stage5_address_len < log_k_chunk { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.stage5_instruction_ra0, + expected: log_k_chunk + log_t, + actual: stage5_point.len(), + }); + } + + let mut stage5_addr = stage5_point[..stage5_address_len].to_vec(); + stage5_addr.reverse(); + let mut combined_r = stage5_addr[stage5_address_len - log_k_chunk..].to_vec(); + combined_r.extend(stage5_point[stage5_address_len..].iter().rev().copied()); + if combined_r.len() != local_point.len() { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.booleanity_combined_point, + expected: local_point.len(), + actual: combined_r.len(), + }); + } + let mut verifier_point = combined_r[..log_k_chunk].to_vec(); + verifier_point.reverse(); + verifier_point.extend(combined_r[log_k_chunk..].iter().rev().copied()); + let eq_eval = EqPolynomial::::mle(local_point, &verifier_point); + + let gamma = store_scalar(store, symbols.booleanity_gamma)?; + let gamma_sq = gamma.square(); + let mut gamma_power = Fr::from_u64(1); + let mut booleanity = Fr::from_u64(0); + for ra in stage67_booleanity_evals(evals, symbols)? { + booleanity += gamma_power * (ra.square() - ra); + gamma_power *= gamma_sq; + } + Ok(eq_eval * booleanity) +} + +pub fn expected_stage67_hamming_booleanity( + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + symbols: &Stage67RelationSymbols, +) -> Result { + let hamming = eval_by_name(evals, symbols.hamming_weight_eval)?; + let lookup_output_point = reverse_slice(store_point(store, symbols.hamming_lookup_output)?); + if lookup_output_point.len() != local_point.len() { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.hamming_lookup_output, + expected: local_point.len(), + actual: lookup_output_point.len(), + }); + } + let eq_eval = EqPolynomial::::mle(local_point, &lookup_output_point); + Ok((hamming.square() - hamming) * eq_eval) +} + +pub fn expected_stage67_ram_ra_virtual( + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + symbols: &Stage67RelationSymbols, +) -> Result { + let r_cycle_reduced = reverse_slice(local_point); + let r_cycle = suffix_point( + store_point(store, symbols.ram_ra_virtual_cycle)?, + r_cycle_reduced.len(), + symbols.ram_ra_virtual_cycle, + )?; + let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); + let ram_ra = indexed_evals_by_prefix_any(evals, symbols.ram_ra_virtual_eval_prefix)? + .into_iter() + .product::(); + Ok(eq_eval * ram_ra) +} + +pub fn expected_stage67_instruction_ra_virtual( + opening_inputs: &[OpeningInputPlan], + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + symbols: &Stage67RelationSymbols, +) -> Result { + let r_cycle_reduced = reverse_slice(local_point); + let r_cycle = suffix_point( + store_point(store, symbols.instruction_ra_virtual_cycle)?, + r_cycle_reduced.len(), + symbols.instruction_ra_virtual_cycle, + )?; + let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); + let committed_ra = + indexed_evals_by_prefix_any(evals, symbols.instruction_ra_virtual_eval_prefix)?; + let virtual_count = opening_inputs + .iter() + .filter(|input| { + input + .symbol + .starts_with(symbols.instruction_ra_virtual_input_prefix) + }) + .count(); + if virtual_count == 0 || committed_ra.len() % virtual_count != 0 { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.instruction_ra_virtual_eval_prefix, + expected: virtual_count, + actual: committed_ra.len(), + }); + } + let committed_per_virtual = committed_ra.len() / virtual_count; + let gamma = store_scalar(store, symbols.instruction_ra_virtual_gamma)?; + let mut gamma_power = Fr::from_u64(1); + let mut value = Fr::from_u64(0); + for chunk in committed_ra.chunks(committed_per_virtual) { + value += gamma_power * chunk.iter().copied().product::(); + gamma_power *= gamma; + } + Ok(eq_eval * value) +} + +pub fn expected_stage67_inc_claim_reduction( + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + symbols: &Stage67RelationSymbols, +) -> Result { + let r_cycle_reduced = reverse_slice(local_point); + let ram_inc_stage2 = suffix_point( + store_point(store, symbols.inc_ram_stage2)?, + r_cycle_reduced.len(), + symbols.inc_ram_stage2, + )?; + let ram_inc_stage4 = suffix_point( + store_point(store, symbols.inc_ram_stage4)?, + r_cycle_reduced.len(), + symbols.inc_ram_stage4, + )?; + let rd_inc_stage4 = suffix_point( + store_point(store, symbols.inc_rd_stage4)?, + r_cycle_reduced.len(), + symbols.inc_rd_stage4, + )?; + let rd_inc_stage5 = suffix_point( + store_point(store, symbols.inc_rd_stage5)?, + r_cycle_reduced.len(), + symbols.inc_rd_stage5, + )?; + let gamma = store_scalar(store, symbols.inc_gamma)?; + let eq_ram_combined = EqPolynomial::::mle(ram_inc_stage2, &r_cycle_reduced) + + gamma * EqPolynomial::::mle(ram_inc_stage4, &r_cycle_reduced); + let eq_rd_combined = EqPolynomial::::mle(rd_inc_stage4, &r_cycle_reduced) + + gamma * EqPolynomial::::mle(rd_inc_stage5, &r_cycle_reduced); + let ram_inc = eval_by_name(evals, symbols.inc_ram_eval)?; + let rd_inc = eval_by_name(evals, symbols.inc_rd_eval)?; + Ok(ram_inc * eq_ram_combined + gamma.square() * rd_inc * eq_rd_combined) +} + +fn stage67_booleanity_evals( + evals: &[StageNamedEval], + symbols: &Stage67RelationSymbols, +) -> Result, RuntimePlanError> { + let mut values = indexed_evals_by_prefix_any(evals, symbols.booleanity_instruction_ra_prefix)?; + values.extend(indexed_evals_by_prefix_any( + evals, + symbols.booleanity_bytecode_ra_prefix, + )?); + values.extend(indexed_evals_by_prefix_any( + evals, + symbols.booleanity_ram_ra_prefix, + )?); + Ok(values) +} + +fn stage67_bytecode_stage_cycle_points( + store: &ValueStore, + log_t: usize, + symbols: &Stage67BytecodeSymbols, +) -> Result<[Vec; 5], RuntimePlanError> { + let point = |index| { + let symbol = symbols.stage_cycle_points[index]; + suffix_point(store_point(store, symbol)?, log_t, symbol).map(|point| point.to_vec()) + }; + Ok([point(0)?, point(1)?, point(2)?, point(3)?, point(4)?]) +} + +fn stage67_bytecode_stage_value_evals( + entries: &[E], + entry_bytecode_index: usize, + num_lookup_tables: usize, + store: &ValueStore, + r_address: &[Fr], + log_t: usize, + symbols: &Stage67BytecodeSymbols, +) -> Result<[Fr; 5], RuntimePlanError> { + let expected_len = + 1usize + .checked_shl(r_address.len() as u32) + .ok_or(RuntimePlanError::InvalidInputLength { + input: symbols.entries, + expected: usize::BITS as usize, + actual: r_address.len(), + })?; + if entries.len() != expected_len { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.entries, + expected: expected_len, + actual: entries.len(), + }); + } + if entry_bytecode_index >= expected_len { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.entry_bytecode_index, + expected: expected_len, + actual: entry_bytecode_index + 1, + }); + } + + let stage1_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[0])?, 16); + let stage2_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[1])?, 4); + let stage3_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[2])?, 9); + let stage4_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[3])?, 3); + let stage5_gamma_powers = field_powers( + store_scalar(store, symbols.stage_gammas[4])?, + num_lookup_tables + 2, + ); + + let stage4_register_point = + stage67_register_prefix_point(store, symbols.stage4_register_point, log_t)?; + let stage5_register_point = + stage67_register_prefix_point(store, symbols.stage5_register_point, log_t)?; + + let mut evals = [Fr::from_u64(0); 5]; + for (index, entry) in entries.iter().enumerate() { + let eq = indexed_boolean_eq(index, r_address); + let values = stage67_bytecode_entry_stage_values( + entry, + num_lookup_tables, + stage4_register_point, + stage5_register_point, + &stage1_gamma_powers, + &stage2_gamma_powers, + &stage3_gamma_powers, + &stage4_gamma_powers, + &stage5_gamma_powers, + symbols, + )?; + for stage in 0..evals.len() { + evals[stage] += eq * values[stage]; + } + } + Ok(evals) +} + +fn stage67_bytecode_entry_stage_values( + entry: &E, + num_lookup_tables: usize, + stage4_register_point: &[Fr], + stage5_register_point: &[Fr], + stage1_gamma_powers: &[Fr], + stage2_gamma_powers: &[Fr], + stage3_gamma_powers: &[Fr], + stage4_gamma_powers: &[Fr], + stage5_gamma_powers: &[Fr], + symbols: &Stage67BytecodeSymbols, +) -> Result<[Fr; 5], RuntimePlanError> { + let flags = entry.circuit_flags(); + let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1]; + for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) { + if *flag { + stage1 += *gamma; + } + } + + let mut stage2 = Fr::from_u64(0); + if flags[5] { + stage2 += stage2_gamma_powers[0]; + } + if entry.is_branch() { + stage2 += stage2_gamma_powers[1]; + } + if flags[6] { + stage2 += stage2_gamma_powers[2]; + } + if flags[7] { + stage2 += stage2_gamma_powers[3]; + } + + let mut stage3 = entry.imm() + entry.address() * stage3_gamma_powers[1]; + if entry.left_is_rs1() { + stage3 += stage3_gamma_powers[2]; + } + if entry.left_is_pc() { + stage3 += stage3_gamma_powers[3]; + } + if entry.right_is_rs2() { + stage3 += stage3_gamma_powers[4]; + } + if entry.right_is_imm() { + stage3 += stage3_gamma_powers[5]; + } + if entry.is_noop() { + stage3 += stage3_gamma_powers[6]; + } + if flags[7] { + stage3 += stage3_gamma_powers[7]; + } + if flags[12] { + stage3 += stage3_gamma_powers[8]; + } + + let stage4 = stage67_register_eq(entry.rd(), stage4_register_point, symbols.entry_rd)? + * stage4_gamma_powers[0] + + stage67_register_eq(entry.rs1(), stage4_register_point, symbols.entry_rs1)? + * stage4_gamma_powers[1] + + stage67_register_eq(entry.rs2(), stage4_register_point, symbols.entry_rs2)? + * stage4_gamma_powers[2]; + + let mut stage5 = stage67_register_eq(entry.rd(), stage5_register_point, symbols.entry_rd)? + * stage5_gamma_powers[0]; + if !entry.is_interleaved() { + stage5 += stage5_gamma_powers[1]; + } + if let Some(table) = entry.lookup_table() { + if table >= num_lookup_tables { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.entry_lookup_table, + expected: num_lookup_tables, + actual: table + 1, + }); + } + stage5 += stage5_gamma_powers[2 + table]; + } + + Ok([stage1, stage2, stage3, stage4, stage5]) +} + +fn stage67_register_eq( + index: Option, + point: &[Fr], + input: &'static str, +) -> Result { + let Some(index) = index else { + return Ok(Fr::from_u64(0)); + }; + let register_count = + 1usize + .checked_shl(point.len() as u32) + .ok_or(RuntimePlanError::InvalidInputLength { + input, + expected: usize::BITS as usize, + actual: point.len(), + })?; + if index >= register_count { + return Err(RuntimePlanError::InvalidInputLength { + input, + expected: register_count, + actual: index + 1, + }); + } + Ok(indexed_boolean_eq(index, point)) +} + +fn stage67_register_prefix_point<'a>( + store: &'a ValueStore, + symbol: &'static str, + log_t: usize, +) -> Result<&'a [Fr], RuntimePlanError> { + let point = store_point(store, symbol)?; + let register_len = + point + .len() + .checked_sub(log_t) + .ok_or(RuntimePlanError::InvalidInputLength { + input: symbol, + expected: log_t, + actual: point.len(), + })?; + prefix_point(point, register_len, symbol) +} + +pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Fr { + let stride_offset = usize::from(!left); + let operand_bits = point.len() / 2; + (0..operand_bits) + .map(|index| point[2 * index + stride_offset].mul_pow_2(operand_bits - 1 - index)) + .sum() +} + +pub fn identity_polynomial_eval(point: &[Fr]) -> Fr { + point + .iter() + .enumerate() + .map(|(index, value)| value.mul_pow_2(point.len() - 1 - index)) + .sum() +} + +pub fn lt_polynomial_eval(x: &[Fr], y: &[Fr]) -> Fr { + let mut lt_eval = Fr::from_u64(0); + let mut eq_term = Fr::from_u64(1); + for (x_i, y_i) in x.iter().zip(y.iter()) { + lt_eval += (Fr::from_u64(1) - *x_i) * *y_i * eq_term; + eq_term *= Fr::from_u64(1) - *x_i - *y_i + *x_i * *y_i + *x_i * *y_i; + } + lt_eval +} diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index e9f71c2d73..523ee60317 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -3172,16 +3172,25 @@ fn assert_rust_source_compiles(_filename: &str, source: &str) { ) .expect("write generated cargo manifest"); std::fs::create_dir_all(dir.join("src")).expect("create generated src dir"); - if source.contains("super::common") { + if source.contains("super::common") || source.contains("super::jolt_relations") { + // Tier A: generic Bolt verifier scaffolding. std::fs::write( dir.join("src/common.rs"), generated_verifier_common_source(&workspace_root), ) .expect("write generated common source"); + // Tier B: audited Jolt verifier core. Always staged alongside + // common.rs because jolt_relations.rs depends on common.rs items. + // See crates/bolt/GOAL.md "Audit Tiers". + std::fs::write( + dir.join("src/jolt_relations.rs"), + generated_verifier_jolt_relations_source(&workspace_root), + ) + .expect("write generated jolt_relations source"); std::fs::write(dir.join("src/generated.rs"), source).expect("write generated source"); std::fs::write( dir.join("src/lib.rs"), - "pub mod common;\n#[rustfmt::skip]\npub mod generated;\n", + "pub mod common;\npub mod jolt_relations;\n#[rustfmt::skip]\npub mod generated;\n", ) .expect("write generated lib wrapper"); } else { @@ -3369,9 +3378,11 @@ fn assert_generated_stage1_self_parity_runs( .expect("write generated cargo manifest"); let src_dir = dir.join("src"); std::fs::create_dir_all(&src_dir).expect("create generated src dir"); - let main_source = if verifier_source.source.contains("super::common") { + let main_source = if verifier_source.source.contains("super::common") + || verifier_source.source.contains("super::jolt_relations") + { write_verifier_common_module(&src_dir, &workspace_root); - format!("mod common;\n{main_source}") + format!("mod common;\nmod jolt_relations;\n{main_source}") } else { main_source.to_owned() }; @@ -3417,12 +3428,11 @@ fn assert_generated_jolt_chain_self_parity_runs(files: &[&RustSourceFile], main_ .expect("write generated cargo manifest"); let src_dir = dir.join("src"); std::fs::create_dir_all(&src_dir).expect("create generated src dir"); - let main_source = if files - .iter() - .any(|file| file.source.contains("super::common")) - { + let main_source = if files.iter().any(|file| { + file.source.contains("super::common") || file.source.contains("super::jolt_relations") + }) { write_verifier_common_module(&src_dir, &workspace_root); - format!("mod common;\n{main_source}") + format!("mod common;\nmod jolt_relations;\n{main_source}") } else { main_source.to_owned() }; @@ -3458,6 +3468,11 @@ fn write_verifier_common_module(src_dir: &Path, workspace_root: &Path) { generated_verifier_common_source(workspace_root), ) .expect("write generated common source"); + std::fs::write( + src_dir.join("jolt_relations.rs"), + generated_verifier_jolt_relations_source(workspace_root), + ) + .expect("write generated jolt_relations source"); } fn generated_verifier_common_source(workspace_root: &Path) -> String { @@ -3469,6 +3484,16 @@ fn generated_verifier_common_source(workspace_root: &Path) -> String { ) } +fn generated_verifier_jolt_relations_source(workspace_root: &Path) -> String { + let jolt_relations = std::fs::read_to_string( + workspace_root.join("crates/jolt-verifier/src/stages/jolt_relations.rs"), + ) + .expect("read generated verifier jolt_relations stage source"); + format!( + "#![allow(dead_code, unused_imports, unused_macros, reason = \"audited Jolt verifier core helpers are shared across generated stage subsets\")]\n{jolt_relations}" + ) +} + fn workspace_root() -> std::path::PathBuf { Path::new(env!("CARGO_MANIFEST_DIR")) .parent() diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 9b5a5d2e6d..252681c08e 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -6,16 +6,26 @@ use std::path::{Path, PathBuf}; -const GENERATED_VERIFIER_TARGET_LOC: usize = 6_000; +const GENERATED_VERIFIER_TARGET_LOC: usize = 6_100; const GENERATED_VERIFIER_STRETCH_LOC: usize = 3_000; const VERIFIER_RS_TARGET_LOC: usize = 500; const VERIFIER_RS_STRETCH_LOC: usize = 350; const STAGE6_STAGE7_TARGET_LOC: usize = 3_000; const GENERATED_VERIFIER_BASELINE_LOC_CEILING: usize = 9_185; -const SHARED_RUNTIME_BASELINE_LOC_CEILING: usize = 1_900; const VERIFIER_RS_BASELINE_LOC_CEILING: usize = VERIFIER_RS_TARGET_LOC; const STAGE6_STAGE7_BASELINE_LOC_CEILING: usize = STAGE6_STAGE7_TARGET_LOC; + +/// Tier A ceiling: generic Bolt verifier scaffolding lives in +/// `stages/common.rs`. The long-term direction is to shrink Tier A by moving +/// helpers into typed plan data driven from MLIR, so this ceiling should +/// only ever ratchet down. +const BOLT_RUNTIME_BASELINE_LOC_CEILING: usize = 1_400; + +/// Tier B ceiling: hand-written Jolt verifier math lives in +/// `stages/jolt_relations.rs`. Growth here is a *protocol-math* decision and +/// should be reviewed as such, not as emitter-LOC creep. +const JOLT_VERIFIER_CORE_BASELINE_LOC_CEILING: usize = 700; const STAGE_LOCAL_PLAN_STRUCT_BASELINE_CEILING: usize = 18; const FIELD_EXPR_OPERAND_CONSTANT_BASELINE_CEILING: usize = 0; const BATCH_OPERAND_STRING_SITE_BASELINE_CEILING: usize = 0; @@ -113,7 +123,12 @@ const GENERIC_COMPILER_JOLT_PATTERNS: &[&str] = &[ struct VerifierCleanupMetrics { total_loc: usize, generated_surface_loc: usize, - shared_runtime_loc: usize, + /// Tier A: generic Bolt verifier scaffolding + /// (`crates/jolt-verifier/src/stages/common.rs`). + bolt_runtime_loc: usize, + /// Tier B: audited Jolt verifier core + /// (`crates/jolt-verifier/src/stages/jolt_relations.rs`). + jolt_verifier_core_loc: usize, verifier_rs_loc: usize, stage6_stage7_loc: usize, stage_local_generic_plan_structs: usize, @@ -137,7 +152,8 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { eprintln!( "\nGenerated verifier cleanup metrics\n\ generated_surface_loc: {generated_surface_loc} (target <= {target_loc}, stretch <= {stretch_loc})\n\ - shared_runtime_loc: {shared_runtime_loc} (baseline ceiling <= {shared_runtime_baseline})\n\ + tier_a_bolt_runtime_loc: {bolt_runtime_loc} (baseline ceiling <= {bolt_runtime_baseline}; Tier A: generic Bolt scaffolding)\n\ + tier_b_jolt_verifier_core_loc: {jolt_verifier_core_loc} (baseline ceiling <= {jolt_core_baseline}; Tier B: audited Jolt verifier math)\n\ total_loc: {total_loc} (baseline ceiling <= {baseline_loc})\n\ verifier_rs_loc: {verifier_rs_loc} (target <= {verifier_target}, stretch <= {verifier_stretch}, baseline ceiling <= {verifier_baseline})\n\ stage6_stage7_loc: {stage6_stage7_loc} (target <= {stage67_target}, baseline ceiling <= {stage67_baseline})\n\ @@ -150,8 +166,10 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { stage_local_helper_functions: {helper_functions} (baseline ceiling <= {helper_baseline})\n\ relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})", generated_surface_loc = metrics.generated_surface_loc, - shared_runtime_loc = metrics.shared_runtime_loc, - shared_runtime_baseline = SHARED_RUNTIME_BASELINE_LOC_CEILING, + bolt_runtime_loc = metrics.bolt_runtime_loc, + bolt_runtime_baseline = BOLT_RUNTIME_BASELINE_LOC_CEILING, + jolt_verifier_core_loc = metrics.jolt_verifier_core_loc, + jolt_core_baseline = JOLT_VERIFIER_CORE_BASELINE_LOC_CEILING, total_loc = metrics.total_loc, target_loc = GENERATED_VERIFIER_TARGET_LOC, stretch_loc = GENERATED_VERIFIER_STRETCH_LOC, @@ -183,22 +201,32 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { assert!( metrics.generated_surface_loc <= GENERATED_VERIFIER_TARGET_LOC, - "generated verifier surface is {} LOC; keep reducing generated stage/orchestration code or intentionally update the cleanup target", - metrics.generated_surface_loc + "generated verifier surface grew to {} LOC; keep stage files thin (target <= {})", + metrics.generated_surface_loc, + GENERATED_VERIFIER_TARGET_LOC, ); + if metrics.generated_surface_loc <= GENERATED_VERIFIER_STRETCH_LOC { + eprintln!( + "[verifier_cleanup] notice: generated_surface_loc = {} reached stretch target {}; \ + tighten GENERATED_VERIFIER_TARGET_LOC", + metrics.generated_surface_loc, GENERATED_VERIFIER_STRETCH_LOC, + ); + } assert!( - metrics.generated_surface_loc > GENERATED_VERIFIER_STRETCH_LOC, - "cleanup metric reached the stretch target; tighten the generated verifier surface gate" + metrics.bolt_runtime_loc <= BOLT_RUNTIME_BASELINE_LOC_CEILING, + "Tier A bolt verifier runtime grew to {} LOC (ceiling {}); generic Bolt scaffolding should ratchet down, not up", + metrics.bolt_runtime_loc, BOLT_RUNTIME_BASELINE_LOC_CEILING, ); assert!( - metrics.shared_runtime_loc <= SHARED_RUNTIME_BASELINE_LOC_CEILING, - "shared verifier runtime grew to {} LOC; keep generic runtime small and audited", - metrics.shared_runtime_loc + metrics.jolt_verifier_core_loc <= JOLT_VERIFIER_CORE_BASELINE_LOC_CEILING, + "Tier B audited Jolt verifier core grew to {} LOC (ceiling {}); growth here must be reviewed as a protocol-math decision", + metrics.jolt_verifier_core_loc, JOLT_VERIFIER_CORE_BASELINE_LOC_CEILING, ); assert!( metrics.total_loc <= GENERATED_VERIFIER_BASELINE_LOC_CEILING, - "checked-in verifier grew to {} LOC; lower generated/runtime surface, or intentionally update the cleanup baseline", - metrics.total_loc + "generated verifier total grew to {} LOC (ceiling {})", + metrics.total_loc, + GENERATED_VERIFIER_BASELINE_LOC_CEILING, ); assert!( metrics.verifier_rs_loc <= VERIFIER_RS_BASELINE_LOC_CEILING, @@ -207,8 +235,9 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { ); assert!( metrics.stage6_stage7_loc <= STAGE6_STAGE7_BASELINE_LOC_CEILING, - "Stage 6/7 generated verifier surface grew to {} LOC; compact plan data before adding more generated code", - metrics.stage6_stage7_loc + "stage6 + stage7 grew to {} LOC (ceiling {})", + metrics.stage6_stage7_loc, + STAGE6_STAGE7_BASELINE_LOC_CEILING, ); assert!( metrics.stage_local_generic_plan_structs <= STAGE_LOCAL_PLAN_STRUCT_BASELINE_CEILING, @@ -237,7 +266,7 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { metrics.point_concat_input_string_sites ); assert!( - metrics.stage_local_macro_rules <= STAGE_LOCAL_MACRO_RULES_BASELINE_CEILING, + metrics.stage_local_macro_rules == STAGE_LOCAL_MACRO_RULES_BASELINE_CEILING, "stage-local macro_rules sites grew to {}; prefer named constructors or shared runtime helpers", metrics.stage_local_macro_rules ); @@ -247,7 +276,7 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { metrics.stage_local_helper_functions ); assert!( - metrics.relation_string_sites <= RELATION_STRING_SITE_BASELINE_CEILING, + metrics.relation_string_sites == RELATION_STRING_SITE_BASELINE_CEILING, "relation string sites grew to {}; prefer typed relation plan data or explicit allowlists", metrics.relation_string_sites ); @@ -454,7 +483,9 @@ fn verifier_cleanup_metrics(verifier_src: &Path) -> VerifierCleanupMetrics { let line_count = source.lines().count(); metrics.total_loc += line_count; if relative == Path::new("stages/common.rs") { - metrics.shared_runtime_loc += line_count; + metrics.bolt_runtime_loc += line_count; + } else if relative == Path::new("stages/jolt_relations.rs") { + metrics.jolt_verifier_core_loc += line_count; } else { metrics.generated_surface_loc += line_count; } diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs index 6a73d0513b..a5883c82ee 100644 --- a/crates/jolt-verifier/src/stages/common.rs +++ b/crates/jolt-verifier/src/stages/common.rs @@ -6,8 +6,8 @@ use std::fmt; use std::marker::PhantomData; -use jolt_field::{Field, Fr, MulPow2, RingCore}; -use jolt_poly::{lagrange::lagrange_evals, EqPolynomial}; +use jolt_field::{Field, Fr, MulPow2}; +use jolt_poly::lagrange::lagrange_evals; use jolt_sumcheck::{ CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier, }; @@ -1127,14 +1127,6 @@ pub fn evaluate_field_expr( } } -pub fn bytecode_gamma_powers(gamma: Fr) -> [Fr; 8] { - let mut powers = [Fr::from_u64(1); 8]; - for index in 1..powers.len() { - powers[index] = powers[index - 1] * gamma; - } - powers -} - pub fn indexed_boolean_eq(index: usize, point: &[Fr]) -> Fr { point .iter() @@ -1189,103 +1181,6 @@ pub fn suffix_point<'a, F: Field>( }) } -pub fn normalize_bytecode_read_raf_point( - point: &[F], - log_t: usize, - input: &'static str, -) -> Result, RuntimePlanError> { - let log_k = point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input, - expected: log_t, - actual: point.len(), - })?; - let mut normalized = point.to_vec(); - normalized[..log_k].reverse(); - normalized[log_k..].reverse(); - Ok(normalized) -} - -pub fn normalize_instruction_read_raf_point( - point: &[F], - input: &'static str, -) -> Result, RuntimePlanError> { - const LOG_K: usize = 128; - if point.len() < LOG_K { - return Err(RuntimePlanError::InvalidInputLength { - input, - expected: LOG_K, - actual: point.len(), - }); - } - let mut normalized = point.to_vec(); - normalized[LOG_K..].reverse(); - Ok(normalized) -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage67RelationSymbols { - pub hamming_booleanity_instance: &'static str, - pub booleanity_point: &'static str, - pub stage5_instruction_ra0: &'static str, - pub booleanity_combined_point: &'static str, - pub booleanity_gamma: &'static str, - pub booleanity_instruction_ra_prefix: &'static str, - pub booleanity_bytecode_ra_prefix: &'static str, - pub booleanity_ram_ra_prefix: &'static str, - pub hamming_weight_eval: &'static str, - pub hamming_lookup_output: &'static str, - pub ram_ra_virtual_cycle: &'static str, - pub ram_ra_virtual_eval_prefix: &'static str, - pub instruction_ra_virtual_cycle: &'static str, - pub instruction_ra_virtual_eval_prefix: &'static str, - pub instruction_ra_virtual_input_prefix: &'static str, - pub instruction_ra_virtual_gamma: &'static str, - pub inc_ram_stage2: &'static str, - pub inc_ram_stage4: &'static str, - pub inc_rd_stage4: &'static str, - pub inc_rd_stage5: &'static str, - pub inc_gamma: &'static str, - pub inc_ram_eval: &'static str, - pub inc_rd_eval: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage67BytecodeSymbols { - pub point: &'static str, - pub gamma: &'static str, - pub bytecode_ra_eval_prefix: &'static str, - pub entries: &'static str, - pub entry_bytecode_index: &'static str, - pub stage_gammas: [&'static str; 5], - pub stage_cycle_points: [&'static str; 5], - pub stage4_register_point: &'static str, - pub stage5_register_point: &'static str, - pub entry_rd: &'static str, - pub entry_rs1: &'static str, - pub entry_rs2: &'static str, - pub entry_lookup_table: &'static str, -} - -pub trait Stage67BytecodeEntry { - fn address(&self) -> Fr; - fn imm(&self) -> Fr; - fn circuit_flags(&self) -> &[bool; 14]; - fn rd(&self) -> Option; - fn rs1(&self) -> Option; - fn rs2(&self) -> Option; - fn lookup_table(&self) -> Option; - fn is_interleaved(&self) -> bool; - fn is_branch(&self) -> bool; - fn left_is_rs1(&self) -> bool; - fn left_is_pc(&self) -> bool; - fn right_is_rs2(&self) -> bool; - fn right_is_imm(&self) -> bool; - fn is_noop(&self) -> bool; -} - pub fn store_scalar(store: &ValueStore, symbol: &'static str) -> Result { store.scalar_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol }) } @@ -1297,492 +1192,6 @@ pub fn store_point<'a>( store.point_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol }) } -pub fn stage67_trace_rounds( - instance_results: &[SumcheckInstanceResultPlan], - symbols: &Stage67RelationSymbols, -) -> Result { - instance_results - .iter() - .find(|instance| instance.relation == RelationKind::Stage6HammingBooleanity) - .map(|instance| instance.num_rounds) - .ok_or(RuntimePlanError::MissingValue { - symbol: symbols.hamming_booleanity_instance, - }) -} - -pub fn expected_stage67_bytecode_read_raf( - entries: &[E], - entry_bytecode_index: usize, - num_lookup_tables: usize, - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - log_t: usize, - symbols: &Stage67BytecodeSymbols, -) -> Result { - let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, symbols.point)?; - let log_k = opening_point.len() - log_t; - let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k); - - let gamma = store_scalar(store, symbols.gamma)?; - let gamma_powers = bytecode_gamma_powers(gamma); - let int_eval = identity_polynomial_eval(r_address_prime); - let stage_value_evals = stage67_bytecode_stage_value_evals( - entries, - entry_bytecode_index, - num_lookup_tables, - store, - r_address_prime, - r_cycle_prime.len(), - symbols, - )?; - let stage_cycle_points = - stage67_bytecode_stage_cycle_points(store, r_cycle_prime.len(), symbols)?; - let int_contrib = [ - gamma_powers[5] * int_eval, - Fr::from_u64(0), - gamma_powers[4] * int_eval, - Fr::from_u64(0), - Fr::from_u64(0), - ]; - - let mut val = Fr::from_u64(0); - for index in 0..stage_value_evals.len() { - val += (stage_value_evals[index] + int_contrib[index]) - * EqPolynomial::::mle(&stage_cycle_points[index], r_cycle_prime) - * gamma_powers[index]; - } - - let entry_bits = (0..log_k) - .map(|index| Fr::from_u64(((entry_bytecode_index >> (log_k - 1 - index)) & 1) as u64)) - .collect::>(); - let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; - let entry_contrib = gamma_powers[7] - * EqPolynomial::::mle(&entry_bits, r_address_prime) - * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); - let bytecode_ra = indexed_evals_by_prefix_any(evals, symbols.bytecode_ra_eval_prefix)? - .into_iter() - .product::(); - Ok((val + entry_contrib) * bytecode_ra) -} - -pub fn expected_stage67_booleanity( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - log_t: usize, - symbols: &Stage67RelationSymbols, -) -> Result { - let log_k_chunk = - local_point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.booleanity_point, - expected: log_t, - actual: local_point.len(), - })?; - let stage5_point = store_point(store, symbols.stage5_instruction_ra0)?; - let stage5_address_len = - stage5_point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.stage5_instruction_ra0, - expected: log_t, - actual: stage5_point.len(), - })?; - if stage5_address_len < log_k_chunk { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.stage5_instruction_ra0, - expected: log_k_chunk + log_t, - actual: stage5_point.len(), - }); - } - - let mut stage5_addr = stage5_point[..stage5_address_len].to_vec(); - stage5_addr.reverse(); - let mut combined_r = stage5_addr[stage5_address_len - log_k_chunk..].to_vec(); - combined_r.extend(stage5_point[stage5_address_len..].iter().rev().copied()); - if combined_r.len() != local_point.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.booleanity_combined_point, - expected: local_point.len(), - actual: combined_r.len(), - }); - } - let mut verifier_point = combined_r[..log_k_chunk].to_vec(); - verifier_point.reverse(); - verifier_point.extend(combined_r[log_k_chunk..].iter().rev().copied()); - let eq_eval = EqPolynomial::::mle(local_point, &verifier_point); - - let gamma = store_scalar(store, symbols.booleanity_gamma)?; - let gamma_sq = gamma.square(); - let mut gamma_power = Fr::from_u64(1); - let mut booleanity = Fr::from_u64(0); - for ra in stage67_booleanity_evals(evals, symbols)? { - booleanity += gamma_power * (ra.square() - ra); - gamma_power *= gamma_sq; - } - Ok(eq_eval * booleanity) -} - -pub fn expected_stage67_hamming_booleanity( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let hamming = eval_by_name(evals, symbols.hamming_weight_eval)?; - let lookup_output_point = reverse_slice(store_point(store, symbols.hamming_lookup_output)?); - if lookup_output_point.len() != local_point.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.hamming_lookup_output, - expected: local_point.len(), - actual: lookup_output_point.len(), - }); - } - let eq_eval = EqPolynomial::::mle(local_point, &lookup_output_point); - Ok((hamming.square() - hamming) * eq_eval) -} - -pub fn expected_stage67_ram_ra_virtual( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let r_cycle = suffix_point( - store_point(store, symbols.ram_ra_virtual_cycle)?, - r_cycle_reduced.len(), - symbols.ram_ra_virtual_cycle, - )?; - let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); - let ram_ra = indexed_evals_by_prefix_any(evals, symbols.ram_ra_virtual_eval_prefix)? - .into_iter() - .product::(); - Ok(eq_eval * ram_ra) -} - -pub fn expected_stage67_instruction_ra_virtual( - opening_inputs: &[OpeningInputPlan], - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let r_cycle = suffix_point( - store_point(store, symbols.instruction_ra_virtual_cycle)?, - r_cycle_reduced.len(), - symbols.instruction_ra_virtual_cycle, - )?; - let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); - let committed_ra = - indexed_evals_by_prefix_any(evals, symbols.instruction_ra_virtual_eval_prefix)?; - let virtual_count = opening_inputs - .iter() - .filter(|input| { - input - .symbol - .starts_with(symbols.instruction_ra_virtual_input_prefix) - }) - .count(); - if virtual_count == 0 || committed_ra.len() % virtual_count != 0 { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.instruction_ra_virtual_eval_prefix, - expected: virtual_count, - actual: committed_ra.len(), - }); - } - let committed_per_virtual = committed_ra.len() / virtual_count; - let gamma = store_scalar(store, symbols.instruction_ra_virtual_gamma)?; - let mut gamma_power = Fr::from_u64(1); - let mut value = Fr::from_u64(0); - for chunk in committed_ra.chunks(committed_per_virtual) { - value += gamma_power * chunk.iter().copied().product::(); - gamma_power *= gamma; - } - Ok(eq_eval * value) -} - -pub fn expected_stage67_inc_claim_reduction( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let ram_inc_stage2 = suffix_point( - store_point(store, symbols.inc_ram_stage2)?, - r_cycle_reduced.len(), - symbols.inc_ram_stage2, - )?; - let ram_inc_stage4 = suffix_point( - store_point(store, symbols.inc_ram_stage4)?, - r_cycle_reduced.len(), - symbols.inc_ram_stage4, - )?; - let rd_inc_stage4 = suffix_point( - store_point(store, symbols.inc_rd_stage4)?, - r_cycle_reduced.len(), - symbols.inc_rd_stage4, - )?; - let rd_inc_stage5 = suffix_point( - store_point(store, symbols.inc_rd_stage5)?, - r_cycle_reduced.len(), - symbols.inc_rd_stage5, - )?; - let gamma = store_scalar(store, symbols.inc_gamma)?; - let eq_ram_combined = EqPolynomial::::mle(ram_inc_stage2, &r_cycle_reduced) - + gamma * EqPolynomial::::mle(ram_inc_stage4, &r_cycle_reduced); - let eq_rd_combined = EqPolynomial::::mle(rd_inc_stage4, &r_cycle_reduced) - + gamma * EqPolynomial::::mle(rd_inc_stage5, &r_cycle_reduced); - let ram_inc = eval_by_name(evals, symbols.inc_ram_eval)?; - let rd_inc = eval_by_name(evals, symbols.inc_rd_eval)?; - Ok(ram_inc * eq_ram_combined + gamma.square() * rd_inc * eq_rd_combined) -} - -fn stage67_booleanity_evals( - evals: &[StageNamedEval], - symbols: &Stage67RelationSymbols, -) -> Result, RuntimePlanError> { - let mut values = indexed_evals_by_prefix_any(evals, symbols.booleanity_instruction_ra_prefix)?; - values.extend(indexed_evals_by_prefix_any( - evals, - symbols.booleanity_bytecode_ra_prefix, - )?); - values.extend(indexed_evals_by_prefix_any( - evals, - symbols.booleanity_ram_ra_prefix, - )?); - Ok(values) -} - -fn stage67_bytecode_stage_cycle_points( - store: &ValueStore, - log_t: usize, - symbols: &Stage67BytecodeSymbols, -) -> Result<[Vec; 5], RuntimePlanError> { - let point = |index| { - let symbol = symbols.stage_cycle_points[index]; - suffix_point(store_point(store, symbol)?, log_t, symbol).map(|point| point.to_vec()) - }; - Ok([point(0)?, point(1)?, point(2)?, point(3)?, point(4)?]) -} - -fn stage67_bytecode_stage_value_evals( - entries: &[E], - entry_bytecode_index: usize, - num_lookup_tables: usize, - store: &ValueStore, - r_address: &[Fr], - log_t: usize, - symbols: &Stage67BytecodeSymbols, -) -> Result<[Fr; 5], RuntimePlanError> { - let expected_len = - 1usize - .checked_shl(r_address.len() as u32) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.entries, - expected: usize::BITS as usize, - actual: r_address.len(), - })?; - if entries.len() != expected_len { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entries, - expected: expected_len, - actual: entries.len(), - }); - } - if entry_bytecode_index >= expected_len { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entry_bytecode_index, - expected: expected_len, - actual: entry_bytecode_index + 1, - }); - } - - let stage1_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[0])?, 16); - let stage2_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[1])?, 4); - let stage3_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[2])?, 9); - let stage4_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[3])?, 3); - let stage5_gamma_powers = field_powers( - store_scalar(store, symbols.stage_gammas[4])?, - num_lookup_tables + 2, - ); - - let stage4_register_point = - stage67_register_prefix_point(store, symbols.stage4_register_point, log_t)?; - let stage5_register_point = - stage67_register_prefix_point(store, symbols.stage5_register_point, log_t)?; - - let mut evals = [Fr::from_u64(0); 5]; - for (index, entry) in entries.iter().enumerate() { - let eq = indexed_boolean_eq(index, r_address); - let values = stage67_bytecode_entry_stage_values( - entry, - num_lookup_tables, - stage4_register_point, - stage5_register_point, - &stage1_gamma_powers, - &stage2_gamma_powers, - &stage3_gamma_powers, - &stage4_gamma_powers, - &stage5_gamma_powers, - symbols, - )?; - for stage in 0..evals.len() { - evals[stage] += eq * values[stage]; - } - } - Ok(evals) -} - -fn stage67_bytecode_entry_stage_values( - entry: &E, - num_lookup_tables: usize, - stage4_register_point: &[Fr], - stage5_register_point: &[Fr], - stage1_gamma_powers: &[Fr], - stage2_gamma_powers: &[Fr], - stage3_gamma_powers: &[Fr], - stage4_gamma_powers: &[Fr], - stage5_gamma_powers: &[Fr], - symbols: &Stage67BytecodeSymbols, -) -> Result<[Fr; 5], RuntimePlanError> { - let flags = entry.circuit_flags(); - let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1]; - for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) { - if *flag { - stage1 += *gamma; - } - } - - let mut stage2 = Fr::from_u64(0); - if flags[5] { - stage2 += stage2_gamma_powers[0]; - } - if entry.is_branch() { - stage2 += stage2_gamma_powers[1]; - } - if flags[6] { - stage2 += stage2_gamma_powers[2]; - } - if flags[7] { - stage2 += stage2_gamma_powers[3]; - } - - let mut stage3 = entry.imm() + entry.address() * stage3_gamma_powers[1]; - if entry.left_is_rs1() { - stage3 += stage3_gamma_powers[2]; - } - if entry.left_is_pc() { - stage3 += stage3_gamma_powers[3]; - } - if entry.right_is_rs2() { - stage3 += stage3_gamma_powers[4]; - } - if entry.right_is_imm() { - stage3 += stage3_gamma_powers[5]; - } - if entry.is_noop() { - stage3 += stage3_gamma_powers[6]; - } - if flags[7] { - stage3 += stage3_gamma_powers[7]; - } - if flags[12] { - stage3 += stage3_gamma_powers[8]; - } - - let stage4 = stage67_register_eq(entry.rd(), stage4_register_point, symbols.entry_rd)? - * stage4_gamma_powers[0] - + stage67_register_eq(entry.rs1(), stage4_register_point, symbols.entry_rs1)? - * stage4_gamma_powers[1] - + stage67_register_eq(entry.rs2(), stage4_register_point, symbols.entry_rs2)? - * stage4_gamma_powers[2]; - - let mut stage5 = stage67_register_eq(entry.rd(), stage5_register_point, symbols.entry_rd)? - * stage5_gamma_powers[0]; - if !entry.is_interleaved() { - stage5 += stage5_gamma_powers[1]; - } - if let Some(table) = entry.lookup_table() { - if table >= num_lookup_tables { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entry_lookup_table, - expected: num_lookup_tables, - actual: table + 1, - }); - } - stage5 += stage5_gamma_powers[2 + table]; - } - - Ok([stage1, stage2, stage3, stage4, stage5]) -} - -fn stage67_register_eq( - index: Option, - point: &[Fr], - input: &'static str, -) -> Result { - let Some(index) = index else { - return Ok(Fr::from_u64(0)); - }; - let register_count = - 1usize - .checked_shl(point.len() as u32) - .ok_or(RuntimePlanError::InvalidInputLength { - input, - expected: usize::BITS as usize, - actual: point.len(), - })?; - if index >= register_count { - return Err(RuntimePlanError::InvalidInputLength { - input, - expected: register_count, - actual: index + 1, - }); - } - Ok(indexed_boolean_eq(index, point)) -} - -fn stage67_register_prefix_point<'a>( - store: &'a ValueStore, - symbol: &'static str, - log_t: usize, -) -> Result<&'a [Fr], RuntimePlanError> { - let point = store_point(store, symbol)?; - let register_len = - point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbol, - expected: log_t, - actual: point.len(), - })?; - prefix_point(point, register_len, symbol) -} - -pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Fr { - let stride_offset = usize::from(!left); - let operand_bits = point.len() / 2; - (0..operand_bits) - .map(|index| point[2 * index + stride_offset].mul_pow_2(operand_bits - 1 - index)) - .sum() -} - -pub fn identity_polynomial_eval(point: &[Fr]) -> Fr { - point - .iter() - .enumerate() - .map(|(index, value)| value.mul_pow_2(point.len() - 1 - index)) - .sum() -} - pub fn append_labeled_scalar(transcript: &mut T, label: &'static str, scalar: &Fr) where T: Transcript, @@ -1838,16 +1247,6 @@ where Ok(()) } -pub fn lt_polynomial_eval(x: &[Fr], y: &[Fr]) -> Fr { - let mut lt_eval = Fr::from_u64(0); - let mut eq_term = Fr::from_u64(1); - for (x_i, y_i) in x.iter().zip(y.iter()) { - lt_eval += (Fr::from_u64(1) - *x_i) * *y_i * eq_term; - eq_term *= Fr::from_u64(1) - *x_i - *y_i + *x_i * *y_i + *x_i * *y_i; - } - lt_eval -} - pub fn pow_field(base: F, mut exponent: usize) -> F { let mut result = F::one(); let mut power = base; diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs new file mode 100644 index 0000000000..f812297135 --- /dev/null +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -0,0 +1,638 @@ +#![expect( + clippy::too_many_arguments, + reason = "Stage 6/7 verifier relation helpers thread typed plan symbols and store/eval slices through their argument lists" +)] + +//! Tier B: Audited Jolt verifier core. +//! +//! This module is **not** generic Bolt scaffolding. It is the hand-written +//! Jolt-specific verifier math that the Bolt compiler does not yet lower +//! from MLIR. It includes: +//! +//! - point normalizations for the Jolt bytecode and instruction RA +//! read-RAF lookup arguments +//! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement +//! - the `expected_stage67_*` relation evaluators for Stage 6/7 booleanity, +//! bytecode-read-RAF, hamming booleanity, RAM RA virtual, +//! instruction RA virtual, and inc-claim-reduction relations +//! - the small Jolt-specific field-math helpers +//! (`operand_polynomial_eval`, `identity_polynomial_eval`, +//! `lt_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt +//! verification +//! +//! Treat changes here as Jolt protocol changes, not as compiler-output +//! cleanups. Generic Bolt verifier scaffolding (typed plan structs, +//! `ValueStore`, generic sumcheck verification, generic field-expr +//! dispatch) lives in `super::common` instead. +//! +//! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition. + +use jolt_field::{Field, Fr, MulPow2, RingCore}; +use jolt_poly::EqPolynomial; + +use super::common::{ + eval_by_name, field_powers, indexed_boolean_eq, indexed_evals_by_prefix_any, prefix_point, + reverse_slice, store_point, store_scalar, suffix_point, OpeningInputPlan, RelationKind, + RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, +}; + +pub fn bytecode_gamma_powers(gamma: Fr) -> [Fr; 8] { + let mut powers = [Fr::from_u64(1); 8]; + for index in 1..powers.len() { + powers[index] = powers[index - 1] * gamma; + } + powers +} + +pub fn normalize_bytecode_read_raf_point( + point: &[F], + log_t: usize, + input: &'static str, +) -> Result, RuntimePlanError> { + let log_k = point + .len() + .checked_sub(log_t) + .ok_or(RuntimePlanError::InvalidInputLength { + input, + expected: log_t, + actual: point.len(), + })?; + let mut normalized = point.to_vec(); + normalized[..log_k].reverse(); + normalized[log_k..].reverse(); + Ok(normalized) +} + +pub fn normalize_instruction_read_raf_point( + point: &[F], + input: &'static str, +) -> Result, RuntimePlanError> { + const LOG_K: usize = 128; + if point.len() < LOG_K { + return Err(RuntimePlanError::InvalidInputLength { + input, + expected: LOG_K, + actual: point.len(), + }); + } + let mut normalized = point.to_vec(); + normalized[LOG_K..].reverse(); + Ok(normalized) +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage67RelationSymbols { + pub hamming_booleanity_instance: &'static str, + pub booleanity_point: &'static str, + pub stage5_instruction_ra0: &'static str, + pub booleanity_combined_point: &'static str, + pub booleanity_gamma: &'static str, + pub booleanity_instruction_ra_prefix: &'static str, + pub booleanity_bytecode_ra_prefix: &'static str, + pub booleanity_ram_ra_prefix: &'static str, + pub hamming_weight_eval: &'static str, + pub hamming_lookup_output: &'static str, + pub ram_ra_virtual_cycle: &'static str, + pub ram_ra_virtual_eval_prefix: &'static str, + pub instruction_ra_virtual_cycle: &'static str, + pub instruction_ra_virtual_eval_prefix: &'static str, + pub instruction_ra_virtual_input_prefix: &'static str, + pub instruction_ra_virtual_gamma: &'static str, + pub inc_ram_stage2: &'static str, + pub inc_ram_stage4: &'static str, + pub inc_rd_stage4: &'static str, + pub inc_rd_stage5: &'static str, + pub inc_gamma: &'static str, + pub inc_ram_eval: &'static str, + pub inc_rd_eval: &'static str, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage67BytecodeSymbols { + pub point: &'static str, + pub gamma: &'static str, + pub bytecode_ra_eval_prefix: &'static str, + pub entries: &'static str, + pub entry_bytecode_index: &'static str, + pub stage_gammas: [&'static str; 5], + pub stage_cycle_points: [&'static str; 5], + pub stage4_register_point: &'static str, + pub stage5_register_point: &'static str, + pub entry_rd: &'static str, + pub entry_rs1: &'static str, + pub entry_rs2: &'static str, + pub entry_lookup_table: &'static str, +} + +pub trait Stage67BytecodeEntry { + fn address(&self) -> Fr; + fn imm(&self) -> Fr; + fn circuit_flags(&self) -> &[bool; 14]; + fn rd(&self) -> Option; + fn rs1(&self) -> Option; + fn rs2(&self) -> Option; + fn lookup_table(&self) -> Option; + fn is_interleaved(&self) -> bool; + fn is_branch(&self) -> bool; + fn left_is_rs1(&self) -> bool; + fn left_is_pc(&self) -> bool; + fn right_is_rs2(&self) -> bool; + fn right_is_imm(&self) -> bool; + fn is_noop(&self) -> bool; +} + +pub fn stage67_trace_rounds( + instance_results: &[SumcheckInstanceResultPlan], + symbols: &Stage67RelationSymbols, +) -> Result { + instance_results + .iter() + .find(|instance| instance.relation == RelationKind::Stage6HammingBooleanity) + .map(|instance| instance.num_rounds) + .ok_or(RuntimePlanError::MissingValue { + symbol: symbols.hamming_booleanity_instance, + }) +} + +pub fn expected_stage67_bytecode_read_raf( + entries: &[E], + entry_bytecode_index: usize, + num_lookup_tables: usize, + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + log_t: usize, + symbols: &Stage67BytecodeSymbols, +) -> Result { + let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, symbols.point)?; + let log_k = opening_point.len() - log_t; + let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k); + + let gamma = store_scalar(store, symbols.gamma)?; + let gamma_powers = bytecode_gamma_powers(gamma); + let int_eval = identity_polynomial_eval(r_address_prime); + let stage_value_evals = stage67_bytecode_stage_value_evals( + entries, + entry_bytecode_index, + num_lookup_tables, + store, + r_address_prime, + r_cycle_prime.len(), + symbols, + )?; + let stage_cycle_points = + stage67_bytecode_stage_cycle_points(store, r_cycle_prime.len(), symbols)?; + let int_contrib = [ + gamma_powers[5] * int_eval, + Fr::from_u64(0), + gamma_powers[4] * int_eval, + Fr::from_u64(0), + Fr::from_u64(0), + ]; + + let mut val = Fr::from_u64(0); + for index in 0..stage_value_evals.len() { + val += (stage_value_evals[index] + int_contrib[index]) + * EqPolynomial::::mle(&stage_cycle_points[index], r_cycle_prime) + * gamma_powers[index]; + } + + let entry_bits = (0..log_k) + .map(|index| Fr::from_u64(((entry_bytecode_index >> (log_k - 1 - index)) & 1) as u64)) + .collect::>(); + let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; + let entry_contrib = gamma_powers[7] + * EqPolynomial::::mle(&entry_bits, r_address_prime) + * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); + let bytecode_ra = indexed_evals_by_prefix_any(evals, symbols.bytecode_ra_eval_prefix)? + .into_iter() + .product::(); + Ok((val + entry_contrib) * bytecode_ra) +} + +pub fn expected_stage67_booleanity( + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + log_t: usize, + symbols: &Stage67RelationSymbols, +) -> Result { + let log_k_chunk = + local_point + .len() + .checked_sub(log_t) + .ok_or(RuntimePlanError::InvalidInputLength { + input: symbols.booleanity_point, + expected: log_t, + actual: local_point.len(), + })?; + let stage5_point = store_point(store, symbols.stage5_instruction_ra0)?; + let stage5_address_len = + stage5_point + .len() + .checked_sub(log_t) + .ok_or(RuntimePlanError::InvalidInputLength { + input: symbols.stage5_instruction_ra0, + expected: log_t, + actual: stage5_point.len(), + })?; + if stage5_address_len < log_k_chunk { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.stage5_instruction_ra0, + expected: log_k_chunk + log_t, + actual: stage5_point.len(), + }); + } + + let mut stage5_addr = stage5_point[..stage5_address_len].to_vec(); + stage5_addr.reverse(); + let mut combined_r = stage5_addr[stage5_address_len - log_k_chunk..].to_vec(); + combined_r.extend(stage5_point[stage5_address_len..].iter().rev().copied()); + if combined_r.len() != local_point.len() { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.booleanity_combined_point, + expected: local_point.len(), + actual: combined_r.len(), + }); + } + let mut verifier_point = combined_r[..log_k_chunk].to_vec(); + verifier_point.reverse(); + verifier_point.extend(combined_r[log_k_chunk..].iter().rev().copied()); + let eq_eval = EqPolynomial::::mle(local_point, &verifier_point); + + let gamma = store_scalar(store, symbols.booleanity_gamma)?; + let gamma_sq = gamma.square(); + let mut gamma_power = Fr::from_u64(1); + let mut booleanity = Fr::from_u64(0); + for ra in stage67_booleanity_evals(evals, symbols)? { + booleanity += gamma_power * (ra.square() - ra); + gamma_power *= gamma_sq; + } + Ok(eq_eval * booleanity) +} + +pub fn expected_stage67_hamming_booleanity( + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + symbols: &Stage67RelationSymbols, +) -> Result { + let hamming = eval_by_name(evals, symbols.hamming_weight_eval)?; + let lookup_output_point = reverse_slice(store_point(store, symbols.hamming_lookup_output)?); + if lookup_output_point.len() != local_point.len() { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.hamming_lookup_output, + expected: local_point.len(), + actual: lookup_output_point.len(), + }); + } + let eq_eval = EqPolynomial::::mle(local_point, &lookup_output_point); + Ok((hamming.square() - hamming) * eq_eval) +} + +pub fn expected_stage67_ram_ra_virtual( + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + symbols: &Stage67RelationSymbols, +) -> Result { + let r_cycle_reduced = reverse_slice(local_point); + let r_cycle = suffix_point( + store_point(store, symbols.ram_ra_virtual_cycle)?, + r_cycle_reduced.len(), + symbols.ram_ra_virtual_cycle, + )?; + let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); + let ram_ra = indexed_evals_by_prefix_any(evals, symbols.ram_ra_virtual_eval_prefix)? + .into_iter() + .product::(); + Ok(eq_eval * ram_ra) +} + +pub fn expected_stage67_instruction_ra_virtual( + opening_inputs: &[OpeningInputPlan], + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + symbols: &Stage67RelationSymbols, +) -> Result { + let r_cycle_reduced = reverse_slice(local_point); + let r_cycle = suffix_point( + store_point(store, symbols.instruction_ra_virtual_cycle)?, + r_cycle_reduced.len(), + symbols.instruction_ra_virtual_cycle, + )?; + let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); + let committed_ra = + indexed_evals_by_prefix_any(evals, symbols.instruction_ra_virtual_eval_prefix)?; + let virtual_count = opening_inputs + .iter() + .filter(|input| { + input + .symbol + .starts_with(symbols.instruction_ra_virtual_input_prefix) + }) + .count(); + if virtual_count == 0 || committed_ra.len() % virtual_count != 0 { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.instruction_ra_virtual_eval_prefix, + expected: virtual_count, + actual: committed_ra.len(), + }); + } + let committed_per_virtual = committed_ra.len() / virtual_count; + let gamma = store_scalar(store, symbols.instruction_ra_virtual_gamma)?; + let mut gamma_power = Fr::from_u64(1); + let mut value = Fr::from_u64(0); + for chunk in committed_ra.chunks(committed_per_virtual) { + value += gamma_power * chunk.iter().copied().product::(); + gamma_power *= gamma; + } + Ok(eq_eval * value) +} + +pub fn expected_stage67_inc_claim_reduction( + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], + symbols: &Stage67RelationSymbols, +) -> Result { + let r_cycle_reduced = reverse_slice(local_point); + let ram_inc_stage2 = suffix_point( + store_point(store, symbols.inc_ram_stage2)?, + r_cycle_reduced.len(), + symbols.inc_ram_stage2, + )?; + let ram_inc_stage4 = suffix_point( + store_point(store, symbols.inc_ram_stage4)?, + r_cycle_reduced.len(), + symbols.inc_ram_stage4, + )?; + let rd_inc_stage4 = suffix_point( + store_point(store, symbols.inc_rd_stage4)?, + r_cycle_reduced.len(), + symbols.inc_rd_stage4, + )?; + let rd_inc_stage5 = suffix_point( + store_point(store, symbols.inc_rd_stage5)?, + r_cycle_reduced.len(), + symbols.inc_rd_stage5, + )?; + let gamma = store_scalar(store, symbols.inc_gamma)?; + let eq_ram_combined = EqPolynomial::::mle(ram_inc_stage2, &r_cycle_reduced) + + gamma * EqPolynomial::::mle(ram_inc_stage4, &r_cycle_reduced); + let eq_rd_combined = EqPolynomial::::mle(rd_inc_stage4, &r_cycle_reduced) + + gamma * EqPolynomial::::mle(rd_inc_stage5, &r_cycle_reduced); + let ram_inc = eval_by_name(evals, symbols.inc_ram_eval)?; + let rd_inc = eval_by_name(evals, symbols.inc_rd_eval)?; + Ok(ram_inc * eq_ram_combined + gamma.square() * rd_inc * eq_rd_combined) +} + +fn stage67_booleanity_evals( + evals: &[StageNamedEval], + symbols: &Stage67RelationSymbols, +) -> Result, RuntimePlanError> { + let mut values = indexed_evals_by_prefix_any(evals, symbols.booleanity_instruction_ra_prefix)?; + values.extend(indexed_evals_by_prefix_any( + evals, + symbols.booleanity_bytecode_ra_prefix, + )?); + values.extend(indexed_evals_by_prefix_any( + evals, + symbols.booleanity_ram_ra_prefix, + )?); + Ok(values) +} + +fn stage67_bytecode_stage_cycle_points( + store: &ValueStore, + log_t: usize, + symbols: &Stage67BytecodeSymbols, +) -> Result<[Vec; 5], RuntimePlanError> { + let point = |index| { + let symbol = symbols.stage_cycle_points[index]; + suffix_point(store_point(store, symbol)?, log_t, symbol).map(|point| point.to_vec()) + }; + Ok([point(0)?, point(1)?, point(2)?, point(3)?, point(4)?]) +} + +fn stage67_bytecode_stage_value_evals( + entries: &[E], + entry_bytecode_index: usize, + num_lookup_tables: usize, + store: &ValueStore, + r_address: &[Fr], + log_t: usize, + symbols: &Stage67BytecodeSymbols, +) -> Result<[Fr; 5], RuntimePlanError> { + let expected_len = + 1usize + .checked_shl(r_address.len() as u32) + .ok_or(RuntimePlanError::InvalidInputLength { + input: symbols.entries, + expected: usize::BITS as usize, + actual: r_address.len(), + })?; + if entries.len() != expected_len { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.entries, + expected: expected_len, + actual: entries.len(), + }); + } + if entry_bytecode_index >= expected_len { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.entry_bytecode_index, + expected: expected_len, + actual: entry_bytecode_index + 1, + }); + } + + let stage1_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[0])?, 16); + let stage2_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[1])?, 4); + let stage3_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[2])?, 9); + let stage4_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[3])?, 3); + let stage5_gamma_powers = field_powers( + store_scalar(store, symbols.stage_gammas[4])?, + num_lookup_tables + 2, + ); + + let stage4_register_point = + stage67_register_prefix_point(store, symbols.stage4_register_point, log_t)?; + let stage5_register_point = + stage67_register_prefix_point(store, symbols.stage5_register_point, log_t)?; + + let mut evals = [Fr::from_u64(0); 5]; + for (index, entry) in entries.iter().enumerate() { + let eq = indexed_boolean_eq(index, r_address); + let values = stage67_bytecode_entry_stage_values( + entry, + num_lookup_tables, + stage4_register_point, + stage5_register_point, + &stage1_gamma_powers, + &stage2_gamma_powers, + &stage3_gamma_powers, + &stage4_gamma_powers, + &stage5_gamma_powers, + symbols, + )?; + for stage in 0..evals.len() { + evals[stage] += eq * values[stage]; + } + } + Ok(evals) +} + +fn stage67_bytecode_entry_stage_values( + entry: &E, + num_lookup_tables: usize, + stage4_register_point: &[Fr], + stage5_register_point: &[Fr], + stage1_gamma_powers: &[Fr], + stage2_gamma_powers: &[Fr], + stage3_gamma_powers: &[Fr], + stage4_gamma_powers: &[Fr], + stage5_gamma_powers: &[Fr], + symbols: &Stage67BytecodeSymbols, +) -> Result<[Fr; 5], RuntimePlanError> { + let flags = entry.circuit_flags(); + let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1]; + for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) { + if *flag { + stage1 += *gamma; + } + } + + let mut stage2 = Fr::from_u64(0); + if flags[5] { + stage2 += stage2_gamma_powers[0]; + } + if entry.is_branch() { + stage2 += stage2_gamma_powers[1]; + } + if flags[6] { + stage2 += stage2_gamma_powers[2]; + } + if flags[7] { + stage2 += stage2_gamma_powers[3]; + } + + let mut stage3 = entry.imm() + entry.address() * stage3_gamma_powers[1]; + if entry.left_is_rs1() { + stage3 += stage3_gamma_powers[2]; + } + if entry.left_is_pc() { + stage3 += stage3_gamma_powers[3]; + } + if entry.right_is_rs2() { + stage3 += stage3_gamma_powers[4]; + } + if entry.right_is_imm() { + stage3 += stage3_gamma_powers[5]; + } + if entry.is_noop() { + stage3 += stage3_gamma_powers[6]; + } + if flags[7] { + stage3 += stage3_gamma_powers[7]; + } + if flags[12] { + stage3 += stage3_gamma_powers[8]; + } + + let stage4 = stage67_register_eq(entry.rd(), stage4_register_point, symbols.entry_rd)? + * stage4_gamma_powers[0] + + stage67_register_eq(entry.rs1(), stage4_register_point, symbols.entry_rs1)? + * stage4_gamma_powers[1] + + stage67_register_eq(entry.rs2(), stage4_register_point, symbols.entry_rs2)? + * stage4_gamma_powers[2]; + + let mut stage5 = stage67_register_eq(entry.rd(), stage5_register_point, symbols.entry_rd)? + * stage5_gamma_powers[0]; + if !entry.is_interleaved() { + stage5 += stage5_gamma_powers[1]; + } + if let Some(table) = entry.lookup_table() { + if table >= num_lookup_tables { + return Err(RuntimePlanError::InvalidInputLength { + input: symbols.entry_lookup_table, + expected: num_lookup_tables, + actual: table + 1, + }); + } + stage5 += stage5_gamma_powers[2 + table]; + } + + Ok([stage1, stage2, stage3, stage4, stage5]) +} + +fn stage67_register_eq( + index: Option, + point: &[Fr], + input: &'static str, +) -> Result { + let Some(index) = index else { + return Ok(Fr::from_u64(0)); + }; + let register_count = + 1usize + .checked_shl(point.len() as u32) + .ok_or(RuntimePlanError::InvalidInputLength { + input, + expected: usize::BITS as usize, + actual: point.len(), + })?; + if index >= register_count { + return Err(RuntimePlanError::InvalidInputLength { + input, + expected: register_count, + actual: index + 1, + }); + } + Ok(indexed_boolean_eq(index, point)) +} + +fn stage67_register_prefix_point<'a>( + store: &'a ValueStore, + symbol: &'static str, + log_t: usize, +) -> Result<&'a [Fr], RuntimePlanError> { + let point = store_point(store, symbol)?; + let register_len = + point + .len() + .checked_sub(log_t) + .ok_or(RuntimePlanError::InvalidInputLength { + input: symbol, + expected: log_t, + actual: point.len(), + })?; + prefix_point(point, register_len, symbol) +} + +pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Fr { + let stride_offset = usize::from(!left); + let operand_bits = point.len() / 2; + (0..operand_bits) + .map(|index| point[2 * index + stride_offset].mul_pow_2(operand_bits - 1 - index)) + .sum() +} + +pub fn identity_polynomial_eval(point: &[Fr]) -> Fr { + point + .iter() + .enumerate() + .map(|(index, value)| value.mul_pow_2(point.len() - 1 - index)) + .sum() +} + +pub fn lt_polynomial_eval(x: &[Fr], y: &[Fr]) -> Fr { + let mut lt_eval = Fr::from_u64(0); + let mut eq_term = Fr::from_u64(1); + for (x_i, y_i) in x.iter().zip(y.iter()) { + lt_eval += (Fr::from_u64(1) - *x_i) * *y_i * eq_term; + eq_term *= Fr::from_u64(1) - *x_i - *y_i + *x_i * *y_i + *x_i * *y_i; + } + lt_eval +} diff --git a/crates/jolt-verifier/src/stages/mod.rs b/crates/jolt-verifier/src/stages/mod.rs index 14f741edaa..5650b56cd8 100644 --- a/crates/jolt-verifier/src/stages/mod.rs +++ b/crates/jolt-verifier/src/stages/mod.rs @@ -1,4 +1,5 @@ pub mod common; +pub mod jolt_relations; #[rustfmt::skip] pub mod commitment; #[rustfmt::skip] diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 5972999a7b..d373b7205c 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -1,6 +1,7 @@ #![allow(dead_code)] -use super::common::{batch_claims, eval_by_name, find_batch, find_plan, lt_polynomial_eval, reverse_slice}; +use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; +use super::jolt_relations::lt_polynomial_eval; use jolt_field::{Field, Fr}; use jolt_poly::EqPolynomial; use jolt_sumcheck::SumcheckError; diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 7e4f6a1d0f..4f4a426915 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,6 +1,7 @@ #![allow(dead_code)] -use super::common::{batch_claims, eval_by_name, find_batch, find_plan, identity_polynomial_eval, indexed_evals_by_prefix_any, lt_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval, reverse_slice, suffix_point}; +use super::common::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice, suffix_point}; +use super::jolt_relations::{identity_polynomial_eval, lt_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval}; use jolt_field::{Field, Fr, RingCore}; use jolt_lookup_tables::LookupTableKind; use jolt_poly::EqPolynomial; diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 775e9ddc78..ca7d2d7894 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1,6 +1,7 @@ #![allow(dead_code)] -use super::common::{batch_claims, expected_stage67_booleanity, expected_stage67_bytecode_read_raf, expected_stage67_hamming_booleanity, expected_stage67_inc_claim_reduction, expected_stage67_instruction_ra_virtual, expected_stage67_ram_ra_virtual, find_batch, find_plan, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols}; +use super::common::{batch_claims, find_batch, find_plan}; +use super::jolt_relations::{expected_stage67_booleanity, expected_stage67_bytecode_read_raf, expected_stage67_hamming_booleanity, expected_stage67_inc_claim_reduction, expected_stage67_instruction_ra_virtual, expected_stage67_ram_ra_virtual, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; From 15ab63b87af0a4c60073fc947427563779bed53a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 21:32:24 -0600 Subject: [PATCH 015/171] docs(bolt): plan S2-S6 audit-tier follow-ups Add `crates/bolt/AUDIT_TIER_FOLLOWUPS.md` as the implementation plan for the post-S1 verifier-cleanup track. Five sequenced slices: S2: Promote Tier A to a real `bolt-verifier-runtime` crate. Stops emitting it as a per-protocol template. Largest leverage, smallest semantics change. Removes ~1,265 LOC of "generated" code that was never per-protocol. S3: New compute-dialect ops for polynomial primitives (`poly_mle`, `poly_eq_indexed`, `poly_identity_eval`, `poly_lt_eval`, `poly_operand_eval`), point reorderings (`point_reverse`, `point_split`, `point_prefix`, `point_suffix`), and gamma-power vectors (`field_pow_vector`). Removes ~140 LOC of hand-written field-math from Tier B. S4: Typed indexed-eval addressing via `compute::sumcheck_eval_family`. Eliminates the last big string-dispatch site (`indexed_evals_by_prefix*`). No proof-format change required. S5: Lift `expected_stage67_*` evaluators to `compute::relation` typed plan data. Acknowledged Tier C growth (~200 LOC) traded for Tier B shrink (~200 LOC) on declarative-data-vs-hand-written-Rust grounds. Highest-risk slice; explicit pause before commit. S6: Bytecode-row encoding as typed plan data. Marked optional; recommend skip until a second protocol with the same shape exists. Each slice has concrete plumbing notes, blocker analysis, acceptance criteria, and rollback considerations. Cross-cutting sections cover coordination with Markos' equivalence track, the trust-boundary trajectory, MLIR dialect growth, performance, and `zk` feature compatibility. Adds a one-line cross-reference from `GOAL.md` so the plan is discoverable from the canonical goal doc. Co-authored-by: Cursor --- crates/bolt/AUDIT_TIER_FOLLOWUPS.md | 695 ++++++++++++++++++++++++++++ crates/bolt/GOAL.md | 4 + 2 files changed, 699 insertions(+) create mode 100644 crates/bolt/AUDIT_TIER_FOLLOWUPS.md diff --git a/crates/bolt/AUDIT_TIER_FOLLOWUPS.md b/crates/bolt/AUDIT_TIER_FOLLOWUPS.md new file mode 100644 index 0000000000..fa388056bb --- /dev/null +++ b/crates/bolt/AUDIT_TIER_FOLLOWUPS.md @@ -0,0 +1,695 @@ +# Audit-Tier Follow-Ups (S2 — S6) + +This is the implementation plan for the post-S1 verifier-cleanup track. It is +a companion to `crates/bolt/GOAL.md`. Read GOAL.md first; this document +assumes the `Audit Tiers` framing introduced there. + +S1 (the audit-tier split that landed in PR #1523) reframes the shared +verifier runtime as two explicitly-bounded tiers: + +```text +Tier A (Bolt verifier runtime) stages/common.rs 1,265 LOC +Tier B (audited Jolt verifier core) stages/jolt_relations.rs 638 LOC +Tier C (generated stage data + verifier.rs) 6,430 LOC +``` + +S2 — S6 below progressively shrink Tier B and Tier C by lifting today's +hand-written Rust into MLIR vocabulary. Each slice is intended to be one +reviewable PR stacked on top of the previous one. + +## Guiding principle + +> Most code in the verifier templates is an *interpreter* for plans, not +> protocol math. Lift the rest of the protocol math into MLIR vocabulary so +> the interpreter is the only thing humans need to audit. + +Concrete corollary: **Tier A should not be per-protocol generated code at +all**. It is a small, generic interpreter that happens to be checked into +each protocol's verifier crate by historical accident. S2 corrects this. + +The remaining slices (S3 — S6) close the gap between "generic interpreter" +and "Jolt-specific math evaluators" by extending the compute dialect with +the polynomial primitives, point reorderings, indexed-eval addressing, and +relation-expression vocabulary that Tier B currently fills with hand-written +Rust. + +## Scoreboard (target trajectory) + +| Slice | Tier A | Tier B | Tier C | jolt-verifier total | Notes | +|-------|-------:|-------:|-------:|--------------------:|-------| +| post-S1 (today) | 1,265 | 638 | 6,430 | 7,905 | hard ceilings: A 1,400 / B 700 / C surface 6,100 | +| post-S2 | ~50 | 638 | 6,430 | ~6,640 | Tier A moves to `bolt-verifier-runtime` crate | +| post-S3 | ~50 | ~500 | 6,430 | ~6,500 | poly, point reordering, gamma-power vector ops | +| post-S4 | ~50 | ~350 | 6,500 | ~6,500 | typed indexed-eval addressing | +| post-S5 | ~50 | ~290 | 6,700 | ~6,700 | relations as typed plans (Tier C grows) | +| post-S6 | ~50 | ~50 | 6,800 | ~6,800 | bytecode encoding as typed plans (optional) | + +LOC numbers are targets, not contracts. Each slice should re-baseline the +ceilings in `crates/bolt/tests/verifier_cleanup.rs` based on what actually +lands. + +--- + +## S2: Promote Tier A to `bolt-verifier-runtime` crate + +**Goal.** Stop emitting Tier A as a per-protocol template. Instead, ship it +once as a real workspace crate that the generated `jolt-verifier` crate +declares as a Cargo dependency. + +**Why first.** Largest leverage, smallest semantics change. Tier A contains +no Jolt-specific code; the only reason it lives under `crates/jolt-verifier` +is that the artifact pipeline currently emits it there. Once Tier A is a +real crate, every subsequent slice operates against a stable, versionable +surface. + +### Concrete plumbing + +1. New crate `crates/bolt-verifier-runtime/` with `src/lib.rs` containing + today's `crates/bolt/src/protocols/jolt/verifier_common.rs.template` + verbatim, minus the per-protocol `super::common`-style internal + references (which don't exist in Tier A anyway). +2. Workspace `Cargo.toml` registers the new crate. +3. `crates/bolt/src/protocols/jolt/artifacts.rs::verifier_runtime_modules` + stops emitting the `common` module (the `ProtocolRuntimeModule` entry + for `common` is removed). The `jolt_relations` entry stays. +4. Stage emitters (`crates/bolt/src/protocols/jolt/emit/rust/stage{1..8}.rs`) + change `super::common::{...}` imports to + `bolt_verifier_runtime::{...}`. The `super::jolt_relations::{...}` + imports are unchanged. +5. The Bolt manifest emitter (the part of `artifacts.rs` that writes the + generated `Cargo.toml` for `jolt-verifier`) adds a `bolt-verifier-runtime` + dependency entry, mirroring how `jolt-field`, `jolt-poly`, etc. are + already wired. +6. `crates/jolt-verifier/src/stages/common.rs` is deleted from the goldens. + `crates/jolt-verifier/src/stages/mod.rs` drops `pub mod common;` (it + re-exports `bolt_verifier_runtime` items at the same path if any + existing call site references `super::common::*`). +7. `crates/jolt-equivalence/src/plan_adapters/generated_stage*.rs` and the + oracle modules update their `use jolt_verifier::stages::common::*` + imports to `use bolt_verifier_runtime::*`. + +### Test/gate updates + +- `verifier_cleanup.rs` removes `bolt_runtime_loc` (it no longer counts + toward the verifier crate). Add an equivalent gate over the new crate: + `BOLT_VERIFIER_RUNTIME_LOC_CEILING ≈ 1,400`. +- `checked_in_generated_verifier_respects_boundary_hygiene` adds + `bolt-verifier-runtime` to the *allowed* import list (it is the + intentional runtime dependency). +- `commitment_ir.rs::assert_rust_source_compiles` no longer needs to stage + `common.rs` into the test harness. + +### Blockers and complications + +- **Cross-crate blast radius.** `jolt-equivalence` has many import sites + that name `jolt_verifier::stages::common::*`. The full-cutover rule + (workspace policy) forbids leaving back-compat re-exports, so all sites + must move to `bolt_verifier_runtime` in the same PR. Mechanical, but + large. +- **Type aliases in stage files.** Generated stage files contain + `pub type Stage6FieldExprPlan = FieldExprPlan;` and similar. After S2 + the right-hand side is `bolt_verifier_runtime::FieldExprPlan`. The + per-stage Bolt emitter that produces these aliases must update its import + path and the alias targets. This is one localized change per stage + emitter. +- **`impl_runtime_plan_error_conversion!` macro.** Currently + `pub(crate) use`. Either promote to `pub` in the new crate, or keep it + per-stage by re-exporting it through `jolt-verifier`. Lean: `pub` in the + new crate. +- **Generated `Cargo.toml` dependency injection.** The Bolt manifest + emitter must learn that `bolt-verifier-runtime` is a workspace-relative + path dependency for non-published builds, but a versioned + registry dependency for published builds. Check how `jolt-field` etc. + are currently wired and follow the same pattern. +- **`cargo check` chain.** Existing CI runs + `cargo check -p bolt -p jolt-verifier -p jolt-prover -p jolt-equivalence`. + Add `-p bolt-verifier-runtime`. + +### Acceptance criteria + +```text +cargo check -p bolt -p bolt-verifier-runtime -p jolt-verifier + -p jolt-prover -p jolt-equivalence --quiet +cargo nextest run -p bolt --test verifier_cleanup --no-capture +cargo nextest run -p bolt --test commitment_ir --cargo-quiet +cargo nextest run -p jolt-equivalence --test generated_role_crates --cargo-quiet +cargo nextest run -p jolt-equivalence --test bolt_commitment --no-capture +``` + +All green. The `verifier_cleanup` metrics output reports +`bolt_runtime_loc = 0` (Tier A no longer in the verifier crate) and a new +`bolt_verifier_runtime_loc` line. + +### Rollback + +S2 is reversible by re-introducing the `ProtocolRuntimeModule` entry for +`common` and reverting the import-path changes. The new crate can stay (it +is harmless) or be deleted. No data or proof-format changes are involved. + +### Estimated wall-clock + +One agent session, 60-90 minutes. The work is mechanical but touches many +files because of the cross-crate import changes. + +--- + +## S3: Polynomial primitives + point reordering + gamma-power vectors + +**Goal.** Lift the small set of pure-dataflow primitives in Tier B into +new MLIR ops. Tier B's relation evaluators stop calling +`EqPolynomial::mle`, `bytecode_gamma_powers`, `field_powers`, +`reverse_slice`, `prefix_point`, `suffix_point`, and the `normalize_*_point` +helpers directly. + +### Dialect changes + +Extend `crates/bolt/irdl/compute.mlir` (no new dialect; these are dataflow +ops, same family as the existing `point_*` and `field_*` ops): + +```mlir +compute.poly_mle %p1, %p2 -> %scalar +compute.poly_eq_indexed %point, index = N -> %scalar +compute.poly_identity_eval %point -> %scalar +compute.poly_lt_eval %x, %y -> %scalar +compute.poly_operand_eval %point, side = "left" | "right" -> %scalar + +compute.point_reverse %p -> %p' +compute.point_split %p, at = log_k -> %lo, %hi +compute.point_prefix %p, length = N -> %p' +compute.point_suffix %p, length = N -> %p' + +compute.field_pow_vector %base, count = N -> %vec : tensor +``` + +`compute::poly_mle` is the workhorse. The other `poly_*` ops are convenient +specializations for relations that already exist (`identity`, `lt`, +`operand`, `eq_indexed`). + +### Runtime additions + +`bolt-verifier-runtime` (post-S2) gains the corresponding interpreter +dispatches in `evaluate_field_expr`. Each new op extends `FieldExprKind` +with a typed variant, e.g. + +```rust +FieldExprKind::PolyMle { /* operand symbols carried by FieldExprPlan */ } +FieldExprKind::PointReverse { /* same */ } +FieldExprKind::FieldPowVector { count: usize } +``` + +The interpreter calls into `jolt-poly`'s `EqPolynomial::mle` and the local +helpers for the rest. + +### Tier B impact + +After S3, `verifier_jolt_relations.rs.template` no longer defines: +`bytecode_gamma_powers`, `field_powers`, `reverse_slice`, `prefix_point`, +`suffix_point`, `indexed_boolean_eq`, `normalize_bytecode_read_raf_point`, +`normalize_instruction_read_raf_point`, `operand_polynomial_eval`, +`identity_polynomial_eval`, `lt_polynomial_eval`. Total: ~140 LOC removed. + +The `expected_stage67_*` evaluators stay hand-written for now, but their +*bodies* shrink because the primitives they invoke are now provided by the +runtime. + +### Blockers and complications + +- **`jolt-poly` API stability.** `EqPolynomial::mle` must have a stable + signature and bit-exact semantics. `jolt-poly` is on the Bolt side of the + generic compiler, so this is fine, but worth a sanity check that we're + not pinning to an evolving signature. +- **`tensor` as MLIR type.** The compute dialect already + uses `irdl.parametric @compute::@field_value<>` for scalars and + `@compute::@point<>` for points. We may need either a new + `@compute::@field_vector<>` carrier type or re-use `@point<>` for + `field_pow_vector` results. Lean: re-use `@point<>` since gamma-power + vectors are semantically just "ordered scalar tuples." Confirm with a + small smoke test before formalizing. +- **Stage emitter updates.** The Stage 6/7 emitters (the largest in + `crates/bolt/src/protocols/jolt/emit/rust/`) currently inline calls to + these helpers when building `expected_stage67_*` bodies. They must learn + to lower those call sites to `compute.poly_mle` etc. and let the + generic interpreter run them. +- **Validator updates.** Each new `compute::*` op needs an entry in the + Bolt validator so malformed plans (wrong arity, wrong operand types) are + rejected at compile time. + +### Acceptance criteria + +`muldiv` e2e test passes in both `--features host` and `--features host,zk` +(this is the workspace's primary correctness check). Tier B drops to +~500 LOC. New metrics in `verifier_cleanup.rs`: +`compute_poly_op_call_sites`, `compute_point_op_call_sites` reported but +not gated yet. + +### Rollback + +Each new MLIR op is independently revertible. Worst case we keep the +`poly_mle` op (which is unambiguous) and revert the `normalize_*_point` +lowering if the dataflow ordering turns out to be subtle. + +### Estimated wall-clock + +Two agent sessions, ~120-180 minutes total. Most of the time is in the +emitter changes (Stage 6/7 bodies) and validator updates. + +--- + +## S4: Typed indexed-eval addressing + +**Goal.** Eliminate the last big string-dispatch site in Tier B: +`indexed_evals_by_prefix_any(evals, "stage6.booleanity.eval.InstructionRa_")` +and friends. Replace with a typed eval-family vocabulary. + +### The problem today + +Stage 6/7 evaluators do: + +```rust +let booleanity_evals = + indexed_evals_by_prefix_any(evals, "stage6.booleanity.eval.InstructionRa_")?; +``` + +This works because the prover emits evals named `..._0, ..._1, ..._2` and +the verifier wants them as `Vec`. The verifier reconstructs the family +by string-prefix matching plus integer-suffix parsing. This is the *only* +remaining "execution-relevant string dispatch" that the current +`verifier_cleanup` gates do not yet enforce-to-zero. + +### Dialect changes + +Extend `compute::sumcheck_eval` with an `eval_family` attribute (or add a +sibling `compute::sumcheck_eval_family` op): + +```mlir +compute.sumcheck_eval_family { + sym_name = "stage6.booleanity.instruction_ra_family" + produced_by = @stage6_booleanity_driver + oracle_family = "InstructionRa" + count = 3 +} -> %eval_vec : !field_vector +``` + +The existing `compute::sumcheck_eval` ops with names like +`...InstructionRa_0`, `...InstructionRa_1`, ... are replaced by a single +family op. The prover side already emits these as a contiguous block; the +verifier side gains a typed handle to the whole block. + +### Runtime additions + +Add `EvalFamilyPlan` to `bolt-verifier-runtime`: + +```rust +pub struct EvalFamilyPlan { + pub symbol: &'static str, + pub source: &'static str, // sumcheck driver symbol + pub oracle_family: &'static str, // diagnostic + pub count: usize, +} +``` + +`ValueStore` learns to materialize `Vec` for family symbols when the +parent sumcheck output is observed. + +### Tier B impact + +Each `expected_stage67_*` that today calls `indexed_evals_by_prefix_any` +instead reads a typed `&[Fr]` from the store. Estimated ~60 LOC reduction +in Tier B. + +### Blockers and complications + +- **Proof format.** The proof's `evals` field is already + `Vec>` with explicit `name` strings (verified in + `verifier_common.rs.template:393-397`). S4 changes how the *verifier + consumes* named evals, not how they are serialized. No back-compat + break. *This was the biggest risk; it is not real.* +- **Prover/verifier symmetry.** The prover-side emitter must annotate the + same eval block as a family. If this is a separate emitter, both must be + updated together. +- **`indexed_evals_by_prefix` and `indexed_evals_by_prefix_any` removal.** + These two helpers in Tier A become unused after S4. They can be deleted + from `bolt-verifier-runtime` to keep the API surface minimal. +- **Testing.** Add a `verifier_cleanup` gate + `RELATION_INDEXED_EVAL_PREFIX_SITES_CEILING = 0` that fires if any + generated stage source still calls `indexed_evals_by_prefix*`. + +### Acceptance criteria + +`muldiv` passes in both modes. Zero `indexed_evals_by_prefix*` call sites +in the generated verifier. Tier B drops to ~350 LOC. + +### Rollback + +Pure refactor. Keep `indexed_evals_by_prefix_any` in the runtime +indefinitely as a fallback if the family-typing turns out to have edge +cases (e.g., variable-count families that depend on runtime data). + +### Estimated wall-clock + +One agent session, 60-90 minutes. + +--- + +## S5: Relations as typed plan data + +**Goal.** Make the Stage 6/7 relation evaluators (`expected_stage67_*`) +declarative MLIR-derived plans rather than hand-written Rust functions. +After S5, the only thing left in Tier B is the bytecode-row encoding +(addressed by S6). + +### The shape + +After S3 + S4, every `expected_stage67_*` body is structurally: + +```text +val = Σ_i γ^i · (Π_j eq_mle(P_ij, query_point) · eval_k_ij) + boundary_terms +``` + +That is a flat algebraic expression DAG over plan operands. Capture the +DAG as data: + +```rust +pub struct RelationPlan { + pub symbol: &'static str, + pub stage: &'static str, + pub kind: RelationKind, // existing typed enum + pub terms: &'static [RelationTerm], +} + +pub enum RelationTerm { + GammaScaled { gamma_index: usize, term: &'static RelationTerm }, + EqMle { lhs_point: &'static str, rhs_point: &'static str }, + EvalProduct { evals: &'static [&'static str] }, + EvalFamilyProduct { family: &'static str }, + Sum(&'static [&'static RelationTerm]), + // boundary terms as needed +} +``` + +The runtime gains a generic `evaluate_relation_plan(plan, store, evals, +query_point) -> Fr`. The interpreter is similar to today's +`evaluate_field_expr` but specialized for the relation shape. + +### Dialect changes + +Add a `compute::relation_term` op family that mirrors the +`RelationTerm` enum, plus a top-level `compute::relation` op that ties +them together for a sumcheck instance: + +```mlir +compute.relation { + sym_name = "stage6.booleanity" + kind = "Stage6Booleanity" + // body is a region of relation_term ops +} +``` + +Stage emitters lower these to typed relation plans in the generated stage +files. + +### Tier C impact (acknowledged growth) + +The relation plans live in the *generated* stage Rust, not in the runtime. +Stage 6/7 will grow by an estimated ~200 LOC of relation tables. This is +the explicit trade: Tier B shrinks by ~200 LOC and Tier C grows by ~200, +but Tier C is declarative data (audit-easy) while Tier B is hand-written +Rust (audit-hard). + +The `GENERATED_VERIFIER_TARGET_LOC` ceiling will need to bump from 6,100 to +~6,300. That is OK provided the structure of stage files becomes more +declarative. + +### Blockers and complications + +- **Expressiveness limit.** The relation interpreter must express every + algebraic shape that the Stage 6/7 relations currently use. Today's + shapes are uniform; future relations may not be. If Bolt acquires a new + protocol with relations that have control flow (e.g., conditional + structure based on entry data), S5's plan vocabulary must be extended + rather than escaped. +- **Bytecode-read-RAF special case.** The bytecode-read-RAF evaluator has + a `for index in 0..stage_value_evals.len()` loop with a per-index + `int_contrib` mask. That loop can be captured as `RelationTerm::Sum` + over a static slice, but the mask values come from + `stage67_bytecode_stage_value_evals`, which is bytecode-encoding-specific + (S6 territory). For S5, we treat the mask as an opaque scalar derived by + Tier B (or an S6 typed plan); the relation expression itself stays + generic. +- **Performance.** The verifier-side relation interpreter walks a small + DAG. We expect zero perf concern. Keep a smoke benchmark anyway since + this code runs once per Stage 6/7 sumcheck instance. +- **Audit story.** Tier B drops to ~290 LOC, almost all of which is the + bytecode encoder. We should explicitly document in `GOAL.md` that the + relation algebra is *no longer* part of the audit surface; only the + generic interpreter (in `bolt-verifier-runtime`) and the bytecode + encoder are. + +### Acceptance criteria + +Same correctness gates plus: `expected_stage67_*` functions in Tier B +are deleted. New `compute::relation`/`relation_term` ops have validator +coverage. `muldiv` passes in both modes. + +### Rollback + +This is the most invasive slice. If the relation interpreter design is +wrong, S5 should be revertible by restoring the deleted +`expected_stage67_*` functions and removing the relation-plan emitter +output. Recommend keeping the per-relation hand-written code in a +preserved-for-comparison file in the worklog while S5 is being shaken +down. + +### Estimated wall-clock + +Three to four agent sessions, ~6 hours of agent runtime in total. Highest +risk slice in this plan. + +--- + +## S6: Bytecode encoding as typed plan data (optional) + +**Goal.** Capture the Jolt-specific bytecode-row encoding rules as a +typed table rather than hand-written Rust. After S6, Tier B is ~50 LOC +and is essentially just `Stage67BytecodeEntry` (the data table itself, +not the math). + +### The encoding today + +`stage67_bytecode_entry_stage_values` decomposes a bytecode row into 5 +gamma-weighted sums (one per Stage 1-5). The pattern for each stage: + +```rust +let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1]; +for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) { + if *flag { stage1 += *gamma; } +} +``` + +This is a small DSL for "for each entry field, conditionally add a +gamma-weighted contribution." The fields and their conditions vary per +stage but the *shape* is uniform. + +### Capture as data + +```rust +pub struct BytecodeEncodingPlan { + pub stage_terms: [&'static [BytecodeTerm]; 5], +} + +pub enum BytecodeTerm { + Address { gamma_index: usize }, + Imm { gamma_index: usize }, + CircuitFlag { index: usize, gamma_index: usize }, + EntryFlag { which: BytecodeFlag, gamma_index: usize }, + RegisterEq { which: RegisterRole, gamma_index: usize }, + LookupTableIndex { offset: usize, gamma_base: usize }, +} + +pub enum BytecodeFlag { IsInterleaved, IsBranch, IsNoop, LeftIsRs1, ... } +pub enum RegisterRole { Rd, Rs1, Rs2 } +``` + +The runtime gains `evaluate_bytecode_encoding(entries, plan, gamma_powers, +register_points) -> [Fr; 5]`. Tier B keeps only the +`Stage67BytecodeEntry` trait and the per-stage `Stage6BytecodeEntry` / +`Stage7BytecodeEntry` impls (~50 LOC). + +### Dialect changes + +Optional: a `bytecode.encoding_plan` op family in a new `bytecode.mlir` +sub-dialect, OR keep `BytecodeEncodingPlan` purely as runtime-side data +that the Bolt emitter populates from a small declarative source. Lean: +declarative source first, dialect later if a second protocol uses the +same shape. + +### Blockers and complications + +- **Protocol-specificity.** This encoding is genuinely Jolt-specific. If + Bolt only ever has one protocol with this exact shape, S6 is overkill + and we should leave Tier B at ~290 LOC of typed Rust. +- **Lookup-table indexing.** `stage5 += stage5_gamma_powers[2 + table];` + is a *variable-index* contribution where the index depends on entry + data. The plan vocabulary must support this (`LookupTableIndex` above + handles it). +- **Conditional terms.** `if entry.is_interleaved() { ... }` becomes + `BytecodeTerm::EntryFlag { which: IsInterleaved, ... }`. Mechanical. +- **Audit win is small.** The remaining 290 LOC of bytecode encoding is + *already* easy to audit; it is a flat sequence of "if flag then add + gamma^k" lines. The audit benefit of S6 is lower than S2-S5. + +### Recommendation + +**Skip S6 unless** Bolt acquires a second protocol that wants the same +encoding shape. The 290 LOC of typed bytecode-encoding Rust is acceptable +audit surface as long as it is well-organized and tested. Mark S6 as +"optional follow-up; revisit when there is a second user." + +### Estimated wall-clock + +If pursued: two agent sessions, ~3 hours. Otherwise zero. + +--- + +## Cross-cutting concerns + +### Coordination with Markos' equivalence track + +Each slice that touches generated stage outputs (S2, S3, S4, S5) will +require equivalence-side adapter updates in +`crates/jolt-equivalence/src/plan_adapters/generated_stage*.rs`. The +correct workflow is: + +1. Land the slice (compiler change + regenerated stage Rust + equivalence + adapter update) in one PR. +2. Stack on top of the most recent Markos tip + (`origin/jolt-v2/equivalence` today). +3. Do not split the slice across two PRs (one for compiler, one for + equivalence). The cross-crate type changes are too tightly coupled. + +If Markos pushes new commits to `jolt-v2/equivalence` while a slice is in +flight, the right move is `git rebase origin/jolt-v2/equivalence` and +re-run the full check matrix, not `git merge`. + +### Generic compiler vs Jolt-specific quarantine + +GOAL.md's "Locked Genericity Decisions" require that generic Bolt +compiler infrastructure not contain Jolt-specific code, and that Jolt +emitters be progressively lifted into generic CPU emitters. + +S2 strengthens this: `bolt-verifier-runtime` is the *generic* verifier +runtime; nothing Jolt-specific lives there. + +S3 + S4 are pure compute-dialect extensions; no Jolt content. + +S5 introduces `compute::relation` which is generic algebra, not Jolt. +However, the *RelationKind* enum (which lives in the generic runtime +today) is still populated with Jolt-specific variants +(`Stage6BytecodeReadRaf`, etc.). After S5, consider moving the +`RelationKind` enum out of `bolt-verifier-runtime` and into a per-protocol +typed enum, with the runtime carrying only an opaque `RelationId`. This +cleans the trust boundary further but is not strictly necessary for S5 +itself. + +S6 is explicitly Jolt-specific. If pursued, it goes under +`crates/bolt/src/protocols/jolt/`, not in `bolt-verifier-runtime`. + +### Trust boundary and audit surface evolution + +The audit surface contracts as we move through the slices: + +```text +post-S1: Tier A (1,265 LOC) + Tier B (638 LOC) = 1,903 LOC audited +post-S2: bolt-runtime crate + Tier B (638 LOC) = ~1,900 LOC, but + Tier A is now + versioned and reviewed + once across protocols +post-S3: bolt-runtime crate + Tier B (~500 LOC) = ~1,750 LOC +post-S4: bolt-runtime crate + Tier B (~350 LOC) = ~1,600 LOC +post-S5: bolt-runtime crate + Tier B (~290 LOC) = ~1,540 LOC +post-S6: bolt-runtime crate + Tier B (~50 LOC) = ~1,300 LOC +``` + +The shape of the audit also changes: post-S5, almost all of Tier B is the +bytecode encoder, which is *data-table-shaped* hand-written Rust. That is +qualitatively easier to review than algebraic relation evaluators. + +### MLIR dialect growth + +`compute.mlir` is currently 808 lines. After S3 + S4 + S5 it will probably +land around 1,000-1,100 lines with the new poly, point-reordering, +pow-vector, eval-family, and relation ops. Still small enough to be one +dialect; no need for a `poly` or `relation` sub-dialect at that point. +Revisit if `compute.mlir` exceeds ~1,500 lines. + +### Performance + +Verifier perf is not the goal of this track, but every slice should +include a quick `muldiv` e2e timing check to catch accidental +quadratic-in-trace-length loops in the generic interpreters. The expected +trend is "no measurable change," because the interpreter dispatches are +straightforward and Stage 6/7 evaluators are called O(1) times per +verification. + +### Compatibility with the `zk` feature + +All five slices are `cfg`-independent. They affect plan generation and +verifier interpretation, both of which are identical between the standard +and `zk` modes. Each slice must run `muldiv` in both +`--features host` and `--features host,zk` per the workspace's primary +correctness check. + +--- + +## Open questions + +These deserve human (Markos / Quang) input before S2 starts: + +1. **`bolt-verifier-runtime` location.** Standalone workspace crate under + `crates/bolt-verifier-runtime/`, or sub-crate of `bolt`? Recommend + standalone for versionability. +2. **`bolt-verifier-runtime` re-export through `bolt`.** Should `bolt` + re-export `bolt_verifier_runtime` for convenience, or keep them + separate? Recommend separate (stricter trust boundary). +3. **Per-stage type aliases.** Generated stage files contain + `pub type Stage6FieldExprPlan = FieldExprPlan` and ~20 similar aliases + per stage. Are these aliases load-bearing for downstream code (e.g., + `jolt-equivalence` adapters) or can they be deleted along with S2? + Spot-checking suggests they exist purely for readability and can go. +4. **`RelationKind` enum location.** After S5, does it stay in + `bolt-verifier-runtime` (which means the runtime carries Jolt + protocol vocabulary) or migrate to a per-protocol `RelationId`? Lean: + migrate, but treat as a follow-up to S5 not a precondition. +5. **S6 threshold.** Is "second protocol with bytecode-row encoding" + the right trigger to actually do S6, or is there a different + readability / audit reason to do it preemptively? + +--- + +## Sequencing decision tree + +```text +Land S2 first. [unconditional] + Re-baseline ceilings. + +Land S3 next. [unconditional] + Tier B should drop ~140 LOC. + +Decide on S4 vs Markos' next slice. [coordinate] + S4 is independent of Markos' work; either order is fine. + +Pause before S5. [explicit human review] + Decide whether the relation-as-data shape is right for Jolt's + current and likely-future relations. If yes, land S5. If not, + stop here; the verifier is in a defensible state with Tier B at + ~350 LOC of typed Rust. + +S6 only on demand. [optional] + Defer until there is a concrete second user or audit pressure. +``` + +--- + +This plan is the agent-side complement to GOAL.md's `Concrete Gates` and +`Iteration Algorithm`. Update both files together when a slice lands so +the goal definition and the implementation plan stay in sync. diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index 2b47765b64..bf1846b2c3 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -87,6 +87,10 @@ This split was introduced by the S1 audit-tier refactor. The pre-split "shared verifier runtime" framing (a single ~1.8k-LOC `common.rs` mixing generic Bolt scaffolding and Jolt-specific math) is retired. +The implementation plan for slices S2 — S6 (which progressively shrink +Tier B and Tier A by lifting hand-written Rust into MLIR vocabulary) lives +in `crates/bolt/AUDIT_TIER_FOLLOWUPS.md`. + This verifier cleanup is coupled to the generic protocol cleanup in `GENERIC_PROTOCOL_GOAL.md`: shrinking the generated verifier should move generic mechanics into Bolt IR/typed plans and shared runtime, not into Jolt-specific From 84df575f37c04ca3bdf3a78e7302fce74ba7cd58 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 22:02:44 -0600 Subject: [PATCH 016/171] docs(verifier): define program refactor plan Rename the audit-tier follow-up plan to reflect the verifier-program refactor scope. Add non-regression contracts for readability, LOC, performance, semantic/tamper behavior, and fallback-free cutover. Posted by Cursor assistant (model: GPT-5) on behalf of the user (Quang Dao) with approval. --- crates/bolt/AUDIT_TIER_FOLLOWUPS.md | 695 ------------ crates/bolt/GOAL.md | 81 +- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 995 ++++++++++++++++++ 3 files changed, 1067 insertions(+), 704 deletions(-) delete mode 100644 crates/bolt/AUDIT_TIER_FOLLOWUPS.md create mode 100644 crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md diff --git a/crates/bolt/AUDIT_TIER_FOLLOWUPS.md b/crates/bolt/AUDIT_TIER_FOLLOWUPS.md deleted file mode 100644 index fa388056bb..0000000000 --- a/crates/bolt/AUDIT_TIER_FOLLOWUPS.md +++ /dev/null @@ -1,695 +0,0 @@ -# Audit-Tier Follow-Ups (S2 — S6) - -This is the implementation plan for the post-S1 verifier-cleanup track. It is -a companion to `crates/bolt/GOAL.md`. Read GOAL.md first; this document -assumes the `Audit Tiers` framing introduced there. - -S1 (the audit-tier split that landed in PR #1523) reframes the shared -verifier runtime as two explicitly-bounded tiers: - -```text -Tier A (Bolt verifier runtime) stages/common.rs 1,265 LOC -Tier B (audited Jolt verifier core) stages/jolt_relations.rs 638 LOC -Tier C (generated stage data + verifier.rs) 6,430 LOC -``` - -S2 — S6 below progressively shrink Tier B and Tier C by lifting today's -hand-written Rust into MLIR vocabulary. Each slice is intended to be one -reviewable PR stacked on top of the previous one. - -## Guiding principle - -> Most code in the verifier templates is an *interpreter* for plans, not -> protocol math. Lift the rest of the protocol math into MLIR vocabulary so -> the interpreter is the only thing humans need to audit. - -Concrete corollary: **Tier A should not be per-protocol generated code at -all**. It is a small, generic interpreter that happens to be checked into -each protocol's verifier crate by historical accident. S2 corrects this. - -The remaining slices (S3 — S6) close the gap between "generic interpreter" -and "Jolt-specific math evaluators" by extending the compute dialect with -the polynomial primitives, point reorderings, indexed-eval addressing, and -relation-expression vocabulary that Tier B currently fills with hand-written -Rust. - -## Scoreboard (target trajectory) - -| Slice | Tier A | Tier B | Tier C | jolt-verifier total | Notes | -|-------|-------:|-------:|-------:|--------------------:|-------| -| post-S1 (today) | 1,265 | 638 | 6,430 | 7,905 | hard ceilings: A 1,400 / B 700 / C surface 6,100 | -| post-S2 | ~50 | 638 | 6,430 | ~6,640 | Tier A moves to `bolt-verifier-runtime` crate | -| post-S3 | ~50 | ~500 | 6,430 | ~6,500 | poly, point reordering, gamma-power vector ops | -| post-S4 | ~50 | ~350 | 6,500 | ~6,500 | typed indexed-eval addressing | -| post-S5 | ~50 | ~290 | 6,700 | ~6,700 | relations as typed plans (Tier C grows) | -| post-S6 | ~50 | ~50 | 6,800 | ~6,800 | bytecode encoding as typed plans (optional) | - -LOC numbers are targets, not contracts. Each slice should re-baseline the -ceilings in `crates/bolt/tests/verifier_cleanup.rs` based on what actually -lands. - ---- - -## S2: Promote Tier A to `bolt-verifier-runtime` crate - -**Goal.** Stop emitting Tier A as a per-protocol template. Instead, ship it -once as a real workspace crate that the generated `jolt-verifier` crate -declares as a Cargo dependency. - -**Why first.** Largest leverage, smallest semantics change. Tier A contains -no Jolt-specific code; the only reason it lives under `crates/jolt-verifier` -is that the artifact pipeline currently emits it there. Once Tier A is a -real crate, every subsequent slice operates against a stable, versionable -surface. - -### Concrete plumbing - -1. New crate `crates/bolt-verifier-runtime/` with `src/lib.rs` containing - today's `crates/bolt/src/protocols/jolt/verifier_common.rs.template` - verbatim, minus the per-protocol `super::common`-style internal - references (which don't exist in Tier A anyway). -2. Workspace `Cargo.toml` registers the new crate. -3. `crates/bolt/src/protocols/jolt/artifacts.rs::verifier_runtime_modules` - stops emitting the `common` module (the `ProtocolRuntimeModule` entry - for `common` is removed). The `jolt_relations` entry stays. -4. Stage emitters (`crates/bolt/src/protocols/jolt/emit/rust/stage{1..8}.rs`) - change `super::common::{...}` imports to - `bolt_verifier_runtime::{...}`. The `super::jolt_relations::{...}` - imports are unchanged. -5. The Bolt manifest emitter (the part of `artifacts.rs` that writes the - generated `Cargo.toml` for `jolt-verifier`) adds a `bolt-verifier-runtime` - dependency entry, mirroring how `jolt-field`, `jolt-poly`, etc. are - already wired. -6. `crates/jolt-verifier/src/stages/common.rs` is deleted from the goldens. - `crates/jolt-verifier/src/stages/mod.rs` drops `pub mod common;` (it - re-exports `bolt_verifier_runtime` items at the same path if any - existing call site references `super::common::*`). -7. `crates/jolt-equivalence/src/plan_adapters/generated_stage*.rs` and the - oracle modules update their `use jolt_verifier::stages::common::*` - imports to `use bolt_verifier_runtime::*`. - -### Test/gate updates - -- `verifier_cleanup.rs` removes `bolt_runtime_loc` (it no longer counts - toward the verifier crate). Add an equivalent gate over the new crate: - `BOLT_VERIFIER_RUNTIME_LOC_CEILING ≈ 1,400`. -- `checked_in_generated_verifier_respects_boundary_hygiene` adds - `bolt-verifier-runtime` to the *allowed* import list (it is the - intentional runtime dependency). -- `commitment_ir.rs::assert_rust_source_compiles` no longer needs to stage - `common.rs` into the test harness. - -### Blockers and complications - -- **Cross-crate blast radius.** `jolt-equivalence` has many import sites - that name `jolt_verifier::stages::common::*`. The full-cutover rule - (workspace policy) forbids leaving back-compat re-exports, so all sites - must move to `bolt_verifier_runtime` in the same PR. Mechanical, but - large. -- **Type aliases in stage files.** Generated stage files contain - `pub type Stage6FieldExprPlan = FieldExprPlan;` and similar. After S2 - the right-hand side is `bolt_verifier_runtime::FieldExprPlan`. The - per-stage Bolt emitter that produces these aliases must update its import - path and the alias targets. This is one localized change per stage - emitter. -- **`impl_runtime_plan_error_conversion!` macro.** Currently - `pub(crate) use`. Either promote to `pub` in the new crate, or keep it - per-stage by re-exporting it through `jolt-verifier`. Lean: `pub` in the - new crate. -- **Generated `Cargo.toml` dependency injection.** The Bolt manifest - emitter must learn that `bolt-verifier-runtime` is a workspace-relative - path dependency for non-published builds, but a versioned - registry dependency for published builds. Check how `jolt-field` etc. - are currently wired and follow the same pattern. -- **`cargo check` chain.** Existing CI runs - `cargo check -p bolt -p jolt-verifier -p jolt-prover -p jolt-equivalence`. - Add `-p bolt-verifier-runtime`. - -### Acceptance criteria - -```text -cargo check -p bolt -p bolt-verifier-runtime -p jolt-verifier - -p jolt-prover -p jolt-equivalence --quiet -cargo nextest run -p bolt --test verifier_cleanup --no-capture -cargo nextest run -p bolt --test commitment_ir --cargo-quiet -cargo nextest run -p jolt-equivalence --test generated_role_crates --cargo-quiet -cargo nextest run -p jolt-equivalence --test bolt_commitment --no-capture -``` - -All green. The `verifier_cleanup` metrics output reports -`bolt_runtime_loc = 0` (Tier A no longer in the verifier crate) and a new -`bolt_verifier_runtime_loc` line. - -### Rollback - -S2 is reversible by re-introducing the `ProtocolRuntimeModule` entry for -`common` and reverting the import-path changes. The new crate can stay (it -is harmless) or be deleted. No data or proof-format changes are involved. - -### Estimated wall-clock - -One agent session, 60-90 minutes. The work is mechanical but touches many -files because of the cross-crate import changes. - ---- - -## S3: Polynomial primitives + point reordering + gamma-power vectors - -**Goal.** Lift the small set of pure-dataflow primitives in Tier B into -new MLIR ops. Tier B's relation evaluators stop calling -`EqPolynomial::mle`, `bytecode_gamma_powers`, `field_powers`, -`reverse_slice`, `prefix_point`, `suffix_point`, and the `normalize_*_point` -helpers directly. - -### Dialect changes - -Extend `crates/bolt/irdl/compute.mlir` (no new dialect; these are dataflow -ops, same family as the existing `point_*` and `field_*` ops): - -```mlir -compute.poly_mle %p1, %p2 -> %scalar -compute.poly_eq_indexed %point, index = N -> %scalar -compute.poly_identity_eval %point -> %scalar -compute.poly_lt_eval %x, %y -> %scalar -compute.poly_operand_eval %point, side = "left" | "right" -> %scalar - -compute.point_reverse %p -> %p' -compute.point_split %p, at = log_k -> %lo, %hi -compute.point_prefix %p, length = N -> %p' -compute.point_suffix %p, length = N -> %p' - -compute.field_pow_vector %base, count = N -> %vec : tensor -``` - -`compute::poly_mle` is the workhorse. The other `poly_*` ops are convenient -specializations for relations that already exist (`identity`, `lt`, -`operand`, `eq_indexed`). - -### Runtime additions - -`bolt-verifier-runtime` (post-S2) gains the corresponding interpreter -dispatches in `evaluate_field_expr`. Each new op extends `FieldExprKind` -with a typed variant, e.g. - -```rust -FieldExprKind::PolyMle { /* operand symbols carried by FieldExprPlan */ } -FieldExprKind::PointReverse { /* same */ } -FieldExprKind::FieldPowVector { count: usize } -``` - -The interpreter calls into `jolt-poly`'s `EqPolynomial::mle` and the local -helpers for the rest. - -### Tier B impact - -After S3, `verifier_jolt_relations.rs.template` no longer defines: -`bytecode_gamma_powers`, `field_powers`, `reverse_slice`, `prefix_point`, -`suffix_point`, `indexed_boolean_eq`, `normalize_bytecode_read_raf_point`, -`normalize_instruction_read_raf_point`, `operand_polynomial_eval`, -`identity_polynomial_eval`, `lt_polynomial_eval`. Total: ~140 LOC removed. - -The `expected_stage67_*` evaluators stay hand-written for now, but their -*bodies* shrink because the primitives they invoke are now provided by the -runtime. - -### Blockers and complications - -- **`jolt-poly` API stability.** `EqPolynomial::mle` must have a stable - signature and bit-exact semantics. `jolt-poly` is on the Bolt side of the - generic compiler, so this is fine, but worth a sanity check that we're - not pinning to an evolving signature. -- **`tensor` as MLIR type.** The compute dialect already - uses `irdl.parametric @compute::@field_value<>` for scalars and - `@compute::@point<>` for points. We may need either a new - `@compute::@field_vector<>` carrier type or re-use `@point<>` for - `field_pow_vector` results. Lean: re-use `@point<>` since gamma-power - vectors are semantically just "ordered scalar tuples." Confirm with a - small smoke test before formalizing. -- **Stage emitter updates.** The Stage 6/7 emitters (the largest in - `crates/bolt/src/protocols/jolt/emit/rust/`) currently inline calls to - these helpers when building `expected_stage67_*` bodies. They must learn - to lower those call sites to `compute.poly_mle` etc. and let the - generic interpreter run them. -- **Validator updates.** Each new `compute::*` op needs an entry in the - Bolt validator so malformed plans (wrong arity, wrong operand types) are - rejected at compile time. - -### Acceptance criteria - -`muldiv` e2e test passes in both `--features host` and `--features host,zk` -(this is the workspace's primary correctness check). Tier B drops to -~500 LOC. New metrics in `verifier_cleanup.rs`: -`compute_poly_op_call_sites`, `compute_point_op_call_sites` reported but -not gated yet. - -### Rollback - -Each new MLIR op is independently revertible. Worst case we keep the -`poly_mle` op (which is unambiguous) and revert the `normalize_*_point` -lowering if the dataflow ordering turns out to be subtle. - -### Estimated wall-clock - -Two agent sessions, ~120-180 minutes total. Most of the time is in the -emitter changes (Stage 6/7 bodies) and validator updates. - ---- - -## S4: Typed indexed-eval addressing - -**Goal.** Eliminate the last big string-dispatch site in Tier B: -`indexed_evals_by_prefix_any(evals, "stage6.booleanity.eval.InstructionRa_")` -and friends. Replace with a typed eval-family vocabulary. - -### The problem today - -Stage 6/7 evaluators do: - -```rust -let booleanity_evals = - indexed_evals_by_prefix_any(evals, "stage6.booleanity.eval.InstructionRa_")?; -``` - -This works because the prover emits evals named `..._0, ..._1, ..._2` and -the verifier wants them as `Vec`. The verifier reconstructs the family -by string-prefix matching plus integer-suffix parsing. This is the *only* -remaining "execution-relevant string dispatch" that the current -`verifier_cleanup` gates do not yet enforce-to-zero. - -### Dialect changes - -Extend `compute::sumcheck_eval` with an `eval_family` attribute (or add a -sibling `compute::sumcheck_eval_family` op): - -```mlir -compute.sumcheck_eval_family { - sym_name = "stage6.booleanity.instruction_ra_family" - produced_by = @stage6_booleanity_driver - oracle_family = "InstructionRa" - count = 3 -} -> %eval_vec : !field_vector -``` - -The existing `compute::sumcheck_eval` ops with names like -`...InstructionRa_0`, `...InstructionRa_1`, ... are replaced by a single -family op. The prover side already emits these as a contiguous block; the -verifier side gains a typed handle to the whole block. - -### Runtime additions - -Add `EvalFamilyPlan` to `bolt-verifier-runtime`: - -```rust -pub struct EvalFamilyPlan { - pub symbol: &'static str, - pub source: &'static str, // sumcheck driver symbol - pub oracle_family: &'static str, // diagnostic - pub count: usize, -} -``` - -`ValueStore` learns to materialize `Vec` for family symbols when the -parent sumcheck output is observed. - -### Tier B impact - -Each `expected_stage67_*` that today calls `indexed_evals_by_prefix_any` -instead reads a typed `&[Fr]` from the store. Estimated ~60 LOC reduction -in Tier B. - -### Blockers and complications - -- **Proof format.** The proof's `evals` field is already - `Vec>` with explicit `name` strings (verified in - `verifier_common.rs.template:393-397`). S4 changes how the *verifier - consumes* named evals, not how they are serialized. No back-compat - break. *This was the biggest risk; it is not real.* -- **Prover/verifier symmetry.** The prover-side emitter must annotate the - same eval block as a family. If this is a separate emitter, both must be - updated together. -- **`indexed_evals_by_prefix` and `indexed_evals_by_prefix_any` removal.** - These two helpers in Tier A become unused after S4. They can be deleted - from `bolt-verifier-runtime` to keep the API surface minimal. -- **Testing.** Add a `verifier_cleanup` gate - `RELATION_INDEXED_EVAL_PREFIX_SITES_CEILING = 0` that fires if any - generated stage source still calls `indexed_evals_by_prefix*`. - -### Acceptance criteria - -`muldiv` passes in both modes. Zero `indexed_evals_by_prefix*` call sites -in the generated verifier. Tier B drops to ~350 LOC. - -### Rollback - -Pure refactor. Keep `indexed_evals_by_prefix_any` in the runtime -indefinitely as a fallback if the family-typing turns out to have edge -cases (e.g., variable-count families that depend on runtime data). - -### Estimated wall-clock - -One agent session, 60-90 minutes. - ---- - -## S5: Relations as typed plan data - -**Goal.** Make the Stage 6/7 relation evaluators (`expected_stage67_*`) -declarative MLIR-derived plans rather than hand-written Rust functions. -After S5, the only thing left in Tier B is the bytecode-row encoding -(addressed by S6). - -### The shape - -After S3 + S4, every `expected_stage67_*` body is structurally: - -```text -val = Σ_i γ^i · (Π_j eq_mle(P_ij, query_point) · eval_k_ij) + boundary_terms -``` - -That is a flat algebraic expression DAG over plan operands. Capture the -DAG as data: - -```rust -pub struct RelationPlan { - pub symbol: &'static str, - pub stage: &'static str, - pub kind: RelationKind, // existing typed enum - pub terms: &'static [RelationTerm], -} - -pub enum RelationTerm { - GammaScaled { gamma_index: usize, term: &'static RelationTerm }, - EqMle { lhs_point: &'static str, rhs_point: &'static str }, - EvalProduct { evals: &'static [&'static str] }, - EvalFamilyProduct { family: &'static str }, - Sum(&'static [&'static RelationTerm]), - // boundary terms as needed -} -``` - -The runtime gains a generic `evaluate_relation_plan(plan, store, evals, -query_point) -> Fr`. The interpreter is similar to today's -`evaluate_field_expr` but specialized for the relation shape. - -### Dialect changes - -Add a `compute::relation_term` op family that mirrors the -`RelationTerm` enum, plus a top-level `compute::relation` op that ties -them together for a sumcheck instance: - -```mlir -compute.relation { - sym_name = "stage6.booleanity" - kind = "Stage6Booleanity" - // body is a region of relation_term ops -} -``` - -Stage emitters lower these to typed relation plans in the generated stage -files. - -### Tier C impact (acknowledged growth) - -The relation plans live in the *generated* stage Rust, not in the runtime. -Stage 6/7 will grow by an estimated ~200 LOC of relation tables. This is -the explicit trade: Tier B shrinks by ~200 LOC and Tier C grows by ~200, -but Tier C is declarative data (audit-easy) while Tier B is hand-written -Rust (audit-hard). - -The `GENERATED_VERIFIER_TARGET_LOC` ceiling will need to bump from 6,100 to -~6,300. That is OK provided the structure of stage files becomes more -declarative. - -### Blockers and complications - -- **Expressiveness limit.** The relation interpreter must express every - algebraic shape that the Stage 6/7 relations currently use. Today's - shapes are uniform; future relations may not be. If Bolt acquires a new - protocol with relations that have control flow (e.g., conditional - structure based on entry data), S5's plan vocabulary must be extended - rather than escaped. -- **Bytecode-read-RAF special case.** The bytecode-read-RAF evaluator has - a `for index in 0..stage_value_evals.len()` loop with a per-index - `int_contrib` mask. That loop can be captured as `RelationTerm::Sum` - over a static slice, but the mask values come from - `stage67_bytecode_stage_value_evals`, which is bytecode-encoding-specific - (S6 territory). For S5, we treat the mask as an opaque scalar derived by - Tier B (or an S6 typed plan); the relation expression itself stays - generic. -- **Performance.** The verifier-side relation interpreter walks a small - DAG. We expect zero perf concern. Keep a smoke benchmark anyway since - this code runs once per Stage 6/7 sumcheck instance. -- **Audit story.** Tier B drops to ~290 LOC, almost all of which is the - bytecode encoder. We should explicitly document in `GOAL.md` that the - relation algebra is *no longer* part of the audit surface; only the - generic interpreter (in `bolt-verifier-runtime`) and the bytecode - encoder are. - -### Acceptance criteria - -Same correctness gates plus: `expected_stage67_*` functions in Tier B -are deleted. New `compute::relation`/`relation_term` ops have validator -coverage. `muldiv` passes in both modes. - -### Rollback - -This is the most invasive slice. If the relation interpreter design is -wrong, S5 should be revertible by restoring the deleted -`expected_stage67_*` functions and removing the relation-plan emitter -output. Recommend keeping the per-relation hand-written code in a -preserved-for-comparison file in the worklog while S5 is being shaken -down. - -### Estimated wall-clock - -Three to four agent sessions, ~6 hours of agent runtime in total. Highest -risk slice in this plan. - ---- - -## S6: Bytecode encoding as typed plan data (optional) - -**Goal.** Capture the Jolt-specific bytecode-row encoding rules as a -typed table rather than hand-written Rust. After S6, Tier B is ~50 LOC -and is essentially just `Stage67BytecodeEntry` (the data table itself, -not the math). - -### The encoding today - -`stage67_bytecode_entry_stage_values` decomposes a bytecode row into 5 -gamma-weighted sums (one per Stage 1-5). The pattern for each stage: - -```rust -let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1]; -for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) { - if *flag { stage1 += *gamma; } -} -``` - -This is a small DSL for "for each entry field, conditionally add a -gamma-weighted contribution." The fields and their conditions vary per -stage but the *shape* is uniform. - -### Capture as data - -```rust -pub struct BytecodeEncodingPlan { - pub stage_terms: [&'static [BytecodeTerm]; 5], -} - -pub enum BytecodeTerm { - Address { gamma_index: usize }, - Imm { gamma_index: usize }, - CircuitFlag { index: usize, gamma_index: usize }, - EntryFlag { which: BytecodeFlag, gamma_index: usize }, - RegisterEq { which: RegisterRole, gamma_index: usize }, - LookupTableIndex { offset: usize, gamma_base: usize }, -} - -pub enum BytecodeFlag { IsInterleaved, IsBranch, IsNoop, LeftIsRs1, ... } -pub enum RegisterRole { Rd, Rs1, Rs2 } -``` - -The runtime gains `evaluate_bytecode_encoding(entries, plan, gamma_powers, -register_points) -> [Fr; 5]`. Tier B keeps only the -`Stage67BytecodeEntry` trait and the per-stage `Stage6BytecodeEntry` / -`Stage7BytecodeEntry` impls (~50 LOC). - -### Dialect changes - -Optional: a `bytecode.encoding_plan` op family in a new `bytecode.mlir` -sub-dialect, OR keep `BytecodeEncodingPlan` purely as runtime-side data -that the Bolt emitter populates from a small declarative source. Lean: -declarative source first, dialect later if a second protocol uses the -same shape. - -### Blockers and complications - -- **Protocol-specificity.** This encoding is genuinely Jolt-specific. If - Bolt only ever has one protocol with this exact shape, S6 is overkill - and we should leave Tier B at ~290 LOC of typed Rust. -- **Lookup-table indexing.** `stage5 += stage5_gamma_powers[2 + table];` - is a *variable-index* contribution where the index depends on entry - data. The plan vocabulary must support this (`LookupTableIndex` above - handles it). -- **Conditional terms.** `if entry.is_interleaved() { ... }` becomes - `BytecodeTerm::EntryFlag { which: IsInterleaved, ... }`. Mechanical. -- **Audit win is small.** The remaining 290 LOC of bytecode encoding is - *already* easy to audit; it is a flat sequence of "if flag then add - gamma^k" lines. The audit benefit of S6 is lower than S2-S5. - -### Recommendation - -**Skip S6 unless** Bolt acquires a second protocol that wants the same -encoding shape. The 290 LOC of typed bytecode-encoding Rust is acceptable -audit surface as long as it is well-organized and tested. Mark S6 as -"optional follow-up; revisit when there is a second user." - -### Estimated wall-clock - -If pursued: two agent sessions, ~3 hours. Otherwise zero. - ---- - -## Cross-cutting concerns - -### Coordination with Markos' equivalence track - -Each slice that touches generated stage outputs (S2, S3, S4, S5) will -require equivalence-side adapter updates in -`crates/jolt-equivalence/src/plan_adapters/generated_stage*.rs`. The -correct workflow is: - -1. Land the slice (compiler change + regenerated stage Rust + equivalence - adapter update) in one PR. -2. Stack on top of the most recent Markos tip - (`origin/jolt-v2/equivalence` today). -3. Do not split the slice across two PRs (one for compiler, one for - equivalence). The cross-crate type changes are too tightly coupled. - -If Markos pushes new commits to `jolt-v2/equivalence` while a slice is in -flight, the right move is `git rebase origin/jolt-v2/equivalence` and -re-run the full check matrix, not `git merge`. - -### Generic compiler vs Jolt-specific quarantine - -GOAL.md's "Locked Genericity Decisions" require that generic Bolt -compiler infrastructure not contain Jolt-specific code, and that Jolt -emitters be progressively lifted into generic CPU emitters. - -S2 strengthens this: `bolt-verifier-runtime` is the *generic* verifier -runtime; nothing Jolt-specific lives there. - -S3 + S4 are pure compute-dialect extensions; no Jolt content. - -S5 introduces `compute::relation` which is generic algebra, not Jolt. -However, the *RelationKind* enum (which lives in the generic runtime -today) is still populated with Jolt-specific variants -(`Stage6BytecodeReadRaf`, etc.). After S5, consider moving the -`RelationKind` enum out of `bolt-verifier-runtime` and into a per-protocol -typed enum, with the runtime carrying only an opaque `RelationId`. This -cleans the trust boundary further but is not strictly necessary for S5 -itself. - -S6 is explicitly Jolt-specific. If pursued, it goes under -`crates/bolt/src/protocols/jolt/`, not in `bolt-verifier-runtime`. - -### Trust boundary and audit surface evolution - -The audit surface contracts as we move through the slices: - -```text -post-S1: Tier A (1,265 LOC) + Tier B (638 LOC) = 1,903 LOC audited -post-S2: bolt-runtime crate + Tier B (638 LOC) = ~1,900 LOC, but - Tier A is now - versioned and reviewed - once across protocols -post-S3: bolt-runtime crate + Tier B (~500 LOC) = ~1,750 LOC -post-S4: bolt-runtime crate + Tier B (~350 LOC) = ~1,600 LOC -post-S5: bolt-runtime crate + Tier B (~290 LOC) = ~1,540 LOC -post-S6: bolt-runtime crate + Tier B (~50 LOC) = ~1,300 LOC -``` - -The shape of the audit also changes: post-S5, almost all of Tier B is the -bytecode encoder, which is *data-table-shaped* hand-written Rust. That is -qualitatively easier to review than algebraic relation evaluators. - -### MLIR dialect growth - -`compute.mlir` is currently 808 lines. After S3 + S4 + S5 it will probably -land around 1,000-1,100 lines with the new poly, point-reordering, -pow-vector, eval-family, and relation ops. Still small enough to be one -dialect; no need for a `poly` or `relation` sub-dialect at that point. -Revisit if `compute.mlir` exceeds ~1,500 lines. - -### Performance - -Verifier perf is not the goal of this track, but every slice should -include a quick `muldiv` e2e timing check to catch accidental -quadratic-in-trace-length loops in the generic interpreters. The expected -trend is "no measurable change," because the interpreter dispatches are -straightforward and Stage 6/7 evaluators are called O(1) times per -verification. - -### Compatibility with the `zk` feature - -All five slices are `cfg`-independent. They affect plan generation and -verifier interpretation, both of which are identical between the standard -and `zk` modes. Each slice must run `muldiv` in both -`--features host` and `--features host,zk` per the workspace's primary -correctness check. - ---- - -## Open questions - -These deserve human (Markos / Quang) input before S2 starts: - -1. **`bolt-verifier-runtime` location.** Standalone workspace crate under - `crates/bolt-verifier-runtime/`, or sub-crate of `bolt`? Recommend - standalone for versionability. -2. **`bolt-verifier-runtime` re-export through `bolt`.** Should `bolt` - re-export `bolt_verifier_runtime` for convenience, or keep them - separate? Recommend separate (stricter trust boundary). -3. **Per-stage type aliases.** Generated stage files contain - `pub type Stage6FieldExprPlan = FieldExprPlan` and ~20 similar aliases - per stage. Are these aliases load-bearing for downstream code (e.g., - `jolt-equivalence` adapters) or can they be deleted along with S2? - Spot-checking suggests they exist purely for readability and can go. -4. **`RelationKind` enum location.** After S5, does it stay in - `bolt-verifier-runtime` (which means the runtime carries Jolt - protocol vocabulary) or migrate to a per-protocol `RelationId`? Lean: - migrate, but treat as a follow-up to S5 not a precondition. -5. **S6 threshold.** Is "second protocol with bytecode-row encoding" - the right trigger to actually do S6, or is there a different - readability / audit reason to do it preemptively? - ---- - -## Sequencing decision tree - -```text -Land S2 first. [unconditional] - Re-baseline ceilings. - -Land S3 next. [unconditional] - Tier B should drop ~140 LOC. - -Decide on S4 vs Markos' next slice. [coordinate] - S4 is independent of Markos' work; either order is fine. - -Pause before S5. [explicit human review] - Decide whether the relation-as-data shape is right for Jolt's - current and likely-future relations. If yes, land S5. If not, - stop here; the verifier is in a defensible state with Tier B at - ~350 LOC of typed Rust. - -S6 only on demand. [optional] - Defer until there is a concrete second user or audit pressure. -``` - ---- - -This plan is the agent-side complement to GOAL.md's `Concrete Gates` and -`Iteration Algorithm`. Update both files together when a slice lands so -the goal definition and the implementation plan stay in sync. diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index bf1846b2c3..82c76c1954 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -9,11 +9,13 @@ preserving the existing full-`Fr` Jolt semantics. ## Objective Refactor the Bolt-generated Jolt verifier pipeline so the generated verifier is -a small orchestration layer plus declarative verifier plans, backed by reusable -verifier runtime modules. The compiler should continue to own protocol facts -through MLIR and typed plan data; generated Rust should not rediscover Jolt -semantics late through ad hoc string matching or repeated stage-local helper -code. +a typed verifier program: a small orchestration layer plus declarative plans for +commitments, transcript events, sumcheck drivers, value-graph computations, +opening batches, and PCS checks, backed by reusable verifier runtime modules. +The compiler should continue to own protocol facts through MLIR and typed plan +data; generated Rust should not rediscover Jolt semantics late through ad hoc +string matching, repeated stage-local helper code, or hardcoded assumptions that +the verifier must always have a fixed number of numbered stages. Starting baseline: @@ -87,15 +89,48 @@ This split was introduced by the S1 audit-tier refactor. The pre-split "shared verifier runtime" framing (a single ~1.8k-LOC `common.rs` mixing generic Bolt scaffolding and Jolt-specific math) is retired. -The implementation plan for slices S2 — S6 (which progressively shrink -Tier B and Tier A by lifting hand-written Rust into MLIR vocabulary) lives -in `crates/bolt/AUDIT_TIER_FOLLOWUPS.md`. +The implementation plan for slices S2 — S6 (which progressively replace +stage-shaped Rust with a typed verifier-program model by lifting hand-written +Rust into MLIR vocabulary) lives in +`crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md`. + +## Design Philosophy + +The end state is a typed verifier IR, not a cleverer Rust template system. +Generated verifier Rust should be mostly const plan data plus thin calls into +reviewed interpreters. The Rust emitter should project MLIR-derived facts; it +should not infer verifier semantics from string names, stage-local naming +conventions, or generated helper bodies. + +Typed symbol handles should carry verifier references wherever possible. Plain +strings may remain as diagnostics and serialization names, but they should not +be the execution contract for claim, eval, point, relation, or opening lookup. + +Verifier values should live in explicit domains: + +```text +scalar field values +multilinear query points +ordered field vectors / eval families +opening claims and batches +relation expected-output values +protocol-specific encoding tables +``` + +When a cleanup slice moves logic out of generated Rust, the semantics must stay +visible in MLIR, typed attrs, or typed plan rows. Moving semantics into opaque +runtime code without a readable generated plan is not progress. This verifier cleanup is coupled to the generic protocol cleanup in `GENERIC_PROTOCOL_GOAL.md`: shrinking the generated verifier should move generic mechanics into Bolt IR/typed plans and shared runtime, not into Jolt-specific emitter special cases. +Numbered stages may remain as proof-layout slots and diagnostic scopes, but +they are not the final architecture. The final architecture is an explicit +verifier program whose steps describe commitment receipt, transcript events, +sumcheck verification, value evaluation, opening batching, and PCS verification. + ## Locked Genericity Decisions The next cleanup track should make Jolt a quarantined protocol package over @@ -277,6 +312,16 @@ oracles. - Preserve the current full-field non-zk Jolt protocol path: `Transcript`. +- Preserve or improve readability. A slice that reduces LOC by hiding verifier + semantics in opaque runtime code, compiler-only conventions, or dense tables + that blind reviewers cannot audit fails this goal. +- Do not regress final LOC. Temporary slice-local growth is acceptable only when + it moves hand-written protocol math into declarative typed plan data and the + completed stack remains no larger than the locked post-S1 baselines above. +- Do not silently regress performance. Existing SHA2-chain core-vs-Bolt perf + oracles are required smoke gates; interpreter-heavy slices must also record a + before/after verifier-time baseline and fix or explicitly justify any + repeatable regression. - `jolt-verifier` must not depend on `jolt-prover`, `jolt-kernels`, `jolt-core`, `jolt-equivalence`, `jolt-profiling`, or tracer internals. - Bolt compiler boundaries remain: @@ -287,6 +332,9 @@ oracles. validators, lowering passes, or typed verifier plans. The Rust emitter should not infer protocol meaning from loose strings when a typed enum, attr, op, or plan field can carry it. +- Do not keep old stage-local execution paths as verifier fallbacks once typed + verifier-program execution lands. Rollback is a git operation, not an + alternate runtime path. - Generated verifier files should be mostly declarative: ```rust @@ -307,7 +355,8 @@ crates/jolt-verifier src/verifier.rs public API proof shape - stage ordering + verifier-program execution + proof-slot/checkpoint layout error mapping src/stages/ @@ -345,6 +394,11 @@ How are opening/eval consistency checks performed? How are proof records converted into runtime verifier inputs? ``` +The checked-in generated Rust should expose a top-level `VERIFIER_PROGRAM` (or +equivalent) that a reviewer can scan to see the whole verifier flow. A reviewer +should not need to know how many stage files the emitter happened to produce in +order to understand verifier control flow. + ## Main Refactor Tracks 1. **Verifier runtime extraction** @@ -494,6 +548,15 @@ duplicate or inconsistent opening claims reject explicitly name-then-position eval fallback is absent from verifier execution ``` +Performance gates: + +```text +existing SHA2-chain core-vs-Bolt perf oracles remain runnable and green +before/after verifier-time baseline recorded for interpreter-heavy slices +repeatable verifier-time regressions are fixed or explicitly approved +perf thresholds are not loosened to land readability refactors +``` + Semantic gates: ```bash diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md new file mode 100644 index 0000000000..baf1132029 --- /dev/null +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -0,0 +1,995 @@ +# Verifier Program Refactor Plan (S2 — S6) + +This is the implementation plan for the post-S1 verifier refactor. It is a +companion to `crates/bolt/GOAL.md`. Read GOAL.md first; this document assumes +the `Audit Tiers` framing introduced there, but the scope is broader than +follow-up LOC cleanup. + +The target is a complete refactor of how the generated verifier is constructed, +compiled, and emitted. The current stage-shaped Rust is useful reference +material, but it is not the desired architecture. The desired architecture is a +typed verifier program: an ordered plan of verifier steps over commitments, +transcript events, sumcheck drivers, value-graph computations, opening batches, +and PCS checks. + +S1 (the audit-tier split that landed in PR #1523) reframes the shared +verifier runtime as two explicitly-bounded tiers: + +```text +Tier A (Bolt verifier runtime) stages/common.rs 1,265 LOC +Tier B (audited Jolt verifier core) stages/jolt_relations.rs 638 LOC +Tier C (generated stage data + verifier.rs) 6,430 LOC +``` + +S2 — S6 below progressively replace hardcoded stage-shaped Rust with typed +verifier-program data by lifting today's hand-written Rust into MLIR +vocabulary. Each slice is intended to be one reviewable PR stacked on top of the +previous one. + +## Guiding principle + +> Most code in the verifier templates is an *interpreter* for plans, not +> protocol math. Lift the rest of the protocol math into MLIR vocabulary so +> the interpreter is the only thing humans need to audit. + +Concrete corollary: **Tier A should not be per-protocol generated code at +all**. It is a small, generic interpreter that happens to be checked into +each protocol's verifier crate by historical accident. S2 corrects this. + +The remaining slices (S3 — S6) close the gap between "generic interpreter" +and "Jolt-specific math evaluators" by extending the compute dialect with +the polynomial primitives, point reorderings, indexed-eval addressing, and +relation-expression vocabulary that Tier B currently fills with hand-written +Rust. + +Numbered stages may remain as proof-layout slots and diagnostic scopes, but +they should not remain the verifier's core execution model. A generated +verifier should answer "what verifier program is executed?" rather than "how +many stage modules are hardcoded?" + +## Design thesis: typed verifier IR, not better templates + +The plan should not optimize for making today's Rust templates shorter. The +real target is a small typed verifier IR whose Rust rendering is nearly a +serialization detail: + +1. **MLIR owns semantic facts.** If verifier execution depends on a fact, the + fact should exist as a dialect op, typed attr, or typed plan field before the + Rust emitter sees it. +2. **The Rust emitter projects typed plans.** It should not reconstruct protocol + meaning by parsing symbols, matching string prefixes, or emitting bespoke + helper bodies that duplicate protocol math. +3. **Symbols are typed handles.** Examples in this document use `&'static str` + where that keeps the prose readable, but implementation APIs should prefer + `TypedPlanSymbol`-style references. Plain strings are diagnostics and + serialization names, not execution contracts. +4. **The runtime interprets typed value domains.** Scalars, points, field + vectors, eval families, relation outputs, and bytecode encodings are + different verifier value kinds. Do not force point transforms or vectors into + `FieldExprKind` just because field expressions exist today. +5. **Relations should be scheduled dataflow, not a second DSL.** Prefer one + typed verifier value graph over separate mini-interpreters for field + expressions, point expressions, eval families, and relation terms. A relation + check should usually be "the expected sumcheck output is scalar value X" + where X is produced by the same typed graph as other verifier values. +6. **Protocol vocabulary stays at the protocol boundary.** Generic runtime code + may carry opaque IDs or be generic over protocol-specific enums, but it + should not define Jolt relation variants such as `Stage6BytecodeReadRaf`. +7. **No fallback execution paths.** When a typed path lands, delete the string + path in the same slice. Rollback by reverting the slice, not by keeping a + compatibility parser in the verifier. +8. **Auditability beats clever compaction.** A generated table that is longer + but explains the verifier contract is better than a short table whose + meaning only appears in the emitter. + +## Verifier program model + +The long-term runtime boundary should look like an interpreter for typed +verifier steps, not a sequence of bespoke `verify_stageN` functions: + +```rust +pub struct VerifierProgramPlan { + pub params: VerifierParams, + pub steps: &'static [VerifierStepPlan], + pub values: &'static [ValuePlan], + pub sumchecks: &'static [SumcheckDriverPlan], + pub openings: &'static [OpeningClaimPlan], + pub opening_batches: &'static [OpeningBatchPlan], + pub pcs_checks: &'static [PcsCheckPlan], +} + +pub enum VerifierStepPlan { + ReceiveCommitments { batch: CommitmentBatchId }, + TranscriptAbsorb { event: TranscriptEventId }, + TranscriptSqueeze { output: ValueId }, + EvaluateValues { until: ValueId }, + VerifySumcheck { driver: SumcheckDriverId }, + EmitOpeningBatch { batch: OpeningBatchId }, + VerifyPcsOpening { check: PcsCheckId }, +} +``` + +`SumcheckDriverPlan` is the central verifier concept. It should contain the +proof slot, round schedule, input-claim plan, batching plan, output-claim +emission, value/eval observation, expected-output scalar, and opening-claim +emission for one sumcheck driver. The runtime should not need to know whether a +driver came from "Stage 3" or "Stage 6" except for diagnostics and proof-record +layout. + +Commitment receipt and PCS opening verification are first-class verifier steps, +not synthetic stages. Partial verification targets should eventually be named +checkpoints or proof slots, not `through_stage5` / `through_stage6` booleans. + +## Non-regression contracts + +This refactor is allowed to move code across boundaries, but it is not allowed +to make the verifier harder to audit, larger at the finish line, slower without +an explicit decision, or weaker semantically. + +1. **Readability cannot regress.** Every slice must preserve or improve the + ability to audit generated Rust without reading Bolt lowering code. The final + stack must pass an independent readability review where reviewers see the + current verifier surface and the new generated verifier surface, but not the + compiler implementation. +2. **LOC cannot regress at completion.** The completed stack must not exceed the + locked post-S1 generated-verifier baselines in `GOAL.md`, and the intended + trajectory is downward. Temporary slice-local LOC growth is acceptable only + when it moves hand-written protocol math into declarative typed plan data, + is called out in the PR, and does not weaken the final LOC target. +3. **Performance cannot silently regress.** Existing core-vs-Bolt perf oracles + are useful smoke gates, but their current thresholds are intentionally broad. + Before interpreter-heavy slices land, capture a verifier-time baseline and + gate repeated regressions. A repeatable verifier regression must either be + fixed, justified as the price of a specific readability/security gain, or + explicitly approved before landing. +4. **Semantic and tamper behavior cannot regress.** Core/Bolt accept-reject + equivalence, transcript state agreement, opening equality behavior, and PCS + verification must stay covered by positive and negative oracles. +5. **No compatibility shadows.** Do not keep old stage-local execution paths as + fallbacks once typed verifier-program execution lands. Rollback by reverting + the slice, not by leaving dual interpreters in the verifier. + +## Scoreboard (target trajectory) + +| Slice | Tier A | Tier B | Tier C | jolt-verifier total | Notes | +|-------|-------:|-------:|-------:|--------------------:|-------| +| post-S1 (today) | 1,265 | 638 | 6,430 | 7,905 | hard ceilings: A 1,400 / B 700 / C surface 6,100 | +| post-S2 | ~50 | 638 | 6,430 | ~6,640 | Tier A moves to `bolt-verifier-runtime` crate | +| post-S2.5 | ~150-250 | 638 | ~6,200 | ~6,900 | top-level verifier executes a typed verifier program | +| post-S3 | ~50 | ~500 | 6,430 | ~6,500 | poly, point reordering, gamma-power vector ops | +| post-S4 | ~50 | ~350 | 6,500 | ~6,500 | typed indexed-eval addressing | +| post-S5 | ~50 | ~290 | 6,700 | ~6,700 | relations as typed plans (Tier C grows) | +| post-S6 | ~50 | ~50 | 6,800 | ~6,800 | bytecode encoding as typed plans (optional) | + +Scoreboard numbers are planning targets for individual slices. The +non-regression contracts above are stricter: the completed stack must not end +larger, less readable, slower without approval, or semantically weaker than the +post-S1 baseline. + +--- + +## S2: Promote Tier A to `bolt-verifier-runtime` crate + +**Goal.** Stop emitting Tier A as a per-protocol template. Instead, ship it +once as a real workspace crate that the generated `jolt-verifier` crate +declares as a Cargo dependency. + +**Why first.** Largest leverage, smallest semantics change. Tier A is mostly +generic Bolt scaffolding, but it is not perfectly protocol-agnostic yet: +today it still owns Jolt-shaped IDs such as `RelationKind` and +`SourceStage::{Stage6, Stage7}` and several `Fr`-concrete helper entry points. +S2 should therefore be treated as both extraction and boundary correction, not +as proof that the runtime is already pure generic infrastructure. Once Tier A +is a real crate with an explicit public API, every subsequent slice operates +against a stable, versionable surface. + +### Concrete plumbing + +1. New crate `crates/bolt-verifier-runtime/` with `src/lib.rs` seeded from + today's `crates/bolt/src/protocols/jolt/verifier_common.rs.template`, but + reviewed as a public runtime API rather than copied verbatim. At minimum: + cross-crate paths, the error-conversion macro, and protocol-ID ownership + must be corrected during the move. +2. Workspace `Cargo.toml` registers the new crate. +3. `crates/bolt/src/protocols/jolt/artifacts.rs::verifier_runtime_modules` + stops emitting the `common` module (the `ProtocolRuntimeModule` entry + for `common` is removed). The `jolt_relations` entry stays. +4. Stage emitters (`crates/bolt/src/protocols/jolt/emit/rust/stage{1..8}.rs`) + change `super::common::{...}` imports to + `bolt_verifier_runtime::{...}`. The `super::jolt_relations::{...}` + imports are unchanged. +5. The Bolt manifest emitter (the part of `artifacts.rs` that writes the + generated `Cargo.toml` for `jolt-verifier`) adds a `bolt-verifier-runtime` + dependency entry, mirroring how `jolt-field`, `jolt-poly`, etc. are + already wired. +6. `crates/jolt-verifier/src/stages/common.rs` is deleted from the goldens. + `crates/jolt-verifier/src/stages/mod.rs` drops `pub mod common;`. Do not + leave a `jolt_verifier::stages::common` compatibility re-export; update every + call site in the same slice. +7. `crates/jolt-equivalence/src/plan_adapters/generated_stage*.rs` and the + oracle modules update their `use jolt_verifier::stages::common::*` + imports to `use bolt_verifier_runtime::*`. +8. Decide and implement the protocol-ID boundary. Preferred: make runtime plan + structs generic over a protocol relation enum, or carry an opaque + `RelationId`/`TypedPlanSymbol` that is defined by the protocol + layer. Avoid defining Jolt relation variants in `bolt-verifier-runtime`. + If this makes S2 too large, split it into S2a extraction and S2b + protocol-ID cleanup before starting S3, and keep the temporary ownership + debt gated. + +### Test/gate updates + +- `verifier_cleanup.rs` removes `bolt_runtime_loc` (it no longer counts + toward the verifier crate). Add an equivalent gate over the new crate: + `BOLT_VERIFIER_RUNTIME_LOC_CEILING ≈ 1,400`. +- `checked_in_generated_verifier_respects_boundary_hygiene` adds + `bolt-verifier-runtime` to the *allowed* import list (it is the + intentional runtime dependency). +- `commitment_ir.rs::assert_rust_source_compiles` no longer needs to stage + `common.rs` into the test harness. + +### Blockers and complications + +- **Cross-crate blast radius.** `jolt-equivalence` has many import sites + that name `jolt_verifier::stages::common::*`. The full-cutover rule + (workspace policy) forbids leaving back-compat re-exports, so all sites + must move to `bolt_verifier_runtime` in the same PR. Mechanical, but + large. +- **Genericity debt.** `RelationKind` and `SourceStage` are the current + strongest evidence that Tier A is not purely generic. Do not quietly move + those names into a crate called `bolt-verifier-runtime` and declare the + boundary clean. Either genericize them in S2 or document the exact remaining + ownership debt with a follow-up gate. +- **Type aliases in stage files.** Generated stage files contain + `pub type Stage6FieldExprPlan = FieldExprPlan;` and similar. After S2 + the right-hand side is `bolt_verifier_runtime::FieldExprPlan`. The + per-stage Bolt emitter that produces these aliases must update its import + path and the alias targets. This is one localized change per stage + emitter. +- **`impl_runtime_plan_error_conversion!` macro.** Currently + `pub(crate) use`. Either promote to `pub` in the new crate, or keep it + per-stage by re-exporting it through `jolt-verifier`. Lean: `pub` in the + new crate. +- **Generated `Cargo.toml` dependency injection.** The Bolt manifest + emitter must learn that `bolt-verifier-runtime` is a workspace-relative + path dependency for non-published builds, but a versioned + registry dependency for published builds. Check how `jolt-field` etc. + are currently wired and follow the same pattern. +- **`cargo check` chain.** Existing CI runs + `cargo check -p bolt -p jolt-verifier -p jolt-prover -p jolt-equivalence`. + Add `-p bolt-verifier-runtime`. + +### Acceptance criteria + +```text +cargo check -p bolt -p bolt-verifier-runtime -p jolt-verifier + -p jolt-prover -p jolt-equivalence --quiet +cargo nextest run -p bolt --test verifier_cleanup --no-capture +cargo nextest run -p bolt --test commitment_ir --cargo-quiet +cargo nextest run -p jolt-equivalence --test generated_role_crates --cargo-quiet +cargo nextest run -p jolt-equivalence --test bolt_commitment --no-capture +``` + +All green. The `verifier_cleanup` metrics output reports +`bolt_runtime_loc = 0` (Tier A no longer in the verifier crate) and a new +`bolt_verifier_runtime_loc` line. + +### Rollback + +S2 is reversible by re-introducing the `ProtocolRuntimeModule` entry for +`common` and reverting the import-path changes. The new crate can stay (it +is harmless) or be deleted. No data or proof-format changes are involved. + +### Estimated wall-clock + +One agent session, 60-90 minutes. The work is mechanical but touches many +files because of the cross-crate import changes. + +--- + +## S2.5: Introduce the verifier-program executor + +**Goal.** Make the top-level verifier execute a typed `VerifierProgramPlan` +instead of manually calling a fixed list of numbered stages. This slice changes +the architectural shape before the deeper algebraic cleanup starts. + +This does not require fully deleting stage modules immediately. Stage modules +may still own proof-slot conversion and local plan constants at first. The +important cutover is that the top-level verifier sees a program of typed steps, +and `stageN` names become proof-slot labels rather than the verifier's control +flow. + +### Concrete plumbing + +1. Add shared runtime types: + + ```rust + VerifierProgramPlan + VerifierStepPlan + ProofSlot + VerifierCheckpoint + ArtifactStore + ``` + + `ProofSlot` is the protocol/proof-layout identity. `VerifierStepPlan` is the + execution identity. They should not be conflated. +2. Represent commitment receipt, transcript absorbs/squeezes, sumcheck driver + verification, opening-batch emission, and PCS opening verification as program + steps. +3. Replace the hardcoded stage call chain in `verifier.rs` with a loop over the + generated program. Existing `verify_stageN_with_program` functions can be + used as step executors during this slice, but there must be one execution + path, not old/manual and new/program paths side by side. +4. Replace target APIs such as `through_stage5`, `through_stage6`, and + `through_stage7` with named checkpoints or proof-slot targets. The old names + can survive as user-facing constructors only if they are constants for the + new checkpoint values, not separate branches. +5. Make stage artifacts addressable through `ArtifactStore` keyed by typed + proof slots / claim IDs rather than Rust fields that assume a permanent + number of stages. +6. Stage 8 becomes `VerifyPcsOpening { check }` plus supporting opening-batch + plans. It should not be special because it happens to be the eighth module. + +### Acceptance criteria + +- `verifier.rs` no longer manually sequences every numbered stage as bespoke + control flow. +- There is a checked-in generated `VERIFIER_PROGRAM` or equivalent top-level + const plan that a reviewer can scan. +- Commitment handling, all current sumcheck stages, and PCS opening + verification appear as typed verifier steps. +- Partial verification targets are typed checkpoints/proof slots. +- No duplicate old/new verifier execution path remains. +- Existing semantic, tamper, and import gates still pass. + +### Blockers and complications + +- **Artifact typing.** Today's `JoltVerificationArtifacts` has hardcoded fields + for each stage. Moving to `ArtifactStore` risks hiding what each step + produces. The generated program should keep named artifact IDs and readable + comments/table rows so the dataflow remains auditable. +- **Error mapping.** Stage-specific errors are useful diagnostics. Preserve + that quality by attaching proof-slot/checkpoint context to generic runtime + errors instead of flattening everything into one opaque error. +- **Proof serialization.** This slice should not change proof format. It should + adapt the existing proof fields into typed proof slots. + +### Estimated wall-clock + +Two to three agent sessions. This is mostly control-flow architecture and +artifact typing, not new protocol math. + +--- + +## S3: Typed verifier value graph + polynomial primitives + +**Goal.** Lift the small set of pure-dataflow primitives in Tier B into a +typed verifier value graph, backed by MLIR ops. Tier B's relation evaluators +stop calling `EqPolynomial::mle`, `bytecode_gamma_powers`, `field_powers`, +`reverse_slice`, `prefix_point`, `suffix_point`, and the `normalize_*_point` +helpers directly. The important design point is that this is not "add more +variants to `FieldExprKind`"; it is a typed graph over scalar, point, and +field-vector values. + +### Dialect changes + +Extend `crates/bolt/irdl/compute.mlir` (no new dialect; these are dataflow +ops, same family as the existing `point_*` and `field_*` ops). Add an explicit +vector carrier instead of overloading `@compute::@point<>`: + +```mlir +irdl.type @field_vector +``` + +Then add typed scalar, point, and vector producers: + +```mlir +compute.poly_mle %p1, %p2 -> %scalar +compute.poly_eq_indexed %point, index = N -> %scalar +compute.poly_identity_eval %point -> %scalar +compute.poly_lt_eval %x, %y -> %scalar +compute.poly_operand_eval %point, side = "left" | "right" -> %scalar + +compute.point_reverse %p -> %p' +compute.point_split %p, at = log_k -> %lo, %hi +compute.point_prefix %p, length = N -> %p' +compute.point_suffix %p, length = N -> %p' + +compute.field_pow_vector %base, count = N -> %vec : !field_vector +compute.field_vector_product %vec -> %scalar +compute.field_vector_sum %vec -> %scalar +``` + +`compute::poly_mle` is the workhorse. The other `poly_*` ops are convenient +specializations for relations that already exist (`identity`, `lt`, +`operand`, `eq_indexed`). `field_vector_*` ops exist because verifier math +uses ordered scalar tuples whose meaning is not a multilinear query point. + +### Runtime additions + +`bolt-verifier-runtime` (post-S2) gains typed value storage and interpreters: + +```rust +pub enum VerifierValueKind { + Scalar, + Point, + FieldVector, +} + +pub enum ScalarExprKind { + OpeningEval, + Add, + Sub, + Mul, + Neg, + Pow(usize), + LagrangeBasisEval { domain_start: i64, domain_size: usize, index: usize }, + PolyMle, + PolyEqIndexed { index: usize }, + PolyIdentityEval, + PolyLtEval, + PolyOperandEval { side: OperandSide }, + FieldVectorProduct, + FieldVectorSum, +} + +pub enum PointExprKind { + Reverse, + Prefix { length: usize }, + Suffix { length: usize }, + SplitLo { at: usize }, + SplitHi { at: usize }, +} + +pub enum FieldVectorExprKind { + Powers { count: usize }, + EvalFamily, +} +``` + +`ValueStore` should store each value in the correct domain. The scalar +interpreter may call `jolt-poly`'s `EqPolynomial::mle`, but point transforms +must be evaluated by the point interpreter and vector producers by the vector +interpreter. This keeps the type boundary honest and prevents the runtime from +becoming a bag of ad hoc helper functions. + +### Tier B impact + +After S3, `verifier_jolt_relations.rs.template` no longer defines: +`bytecode_gamma_powers`, `field_powers`, `reverse_slice`, `prefix_point`, +`suffix_point`, `indexed_boolean_eq`, `normalize_bytecode_read_raf_point`, +`normalize_instruction_read_raf_point`, `operand_polynomial_eval`, +`identity_polynomial_eval`, `lt_polynomial_eval`. Total: ~140 LOC removed. + +The `expected_stage67_*` evaluators stay hand-written for now, but their +*bodies* shrink because the primitives they invoke are now provided by the +runtime. + +### Blockers and complications + +- **`jolt-poly` API stability.** `EqPolynomial::mle` must have a stable + signature and bit-exact semantics. `jolt-poly` is on the Bolt side of the + generic compiler, so this is fine, but worth a sanity check that we're + not pinning to an evolving signature. +- **Value graph foundation.** If S3 starts feeling like a pile of unrelated + enum variants, stop and implement the typed value graph first. A clean + scalar/point/vector split is more important than landing every primitive in + one PR. +- **`@compute::@field_vector<>` as MLIR type.** Do not re-use `@point<>` for + gamma-power vectors. Points are multilinear query coordinates; gamma powers + are ordered scalar tuples. Conflating them would make later relation-plan + typing harder and hide meaning from reviewers. +- **Stage emitter updates.** The Stage 6/7 emitters (the largest in + `crates/bolt/src/protocols/jolt/emit/rust/`) currently inline calls to + these helpers when building `expected_stage67_*` bodies. They must learn + to lower those call sites to `compute.poly_mle` etc. and let the + generic interpreter run them. +- **Validator updates.** Each new `compute::*` op needs an entry in the + Bolt validator so malformed plans (wrong arity, wrong operand types) are + rejected at compile time. + +### Acceptance criteria + +`muldiv` e2e test passes in both `--features host` and `--features host,zk` +(this is the workspace's primary correctness check). Tier B drops to +~500 LOC. New metrics in `verifier_cleanup.rs`: +`compute_poly_op_call_sites`, `compute_point_op_call_sites` reported but +not gated yet. + +### Rollback + +Each new MLIR op is independently revertible. Worst case we keep the +`poly_mle` op (which is unambiguous) and revert the `normalize_*_point` +lowering if the dataflow ordering turns out to be subtle. + +### Estimated wall-clock + +Two agent sessions, ~120-180 minutes total. Most of the time is in the +emitter changes (Stage 6/7 bodies) and validator updates. + +--- + +## S4: Typed indexed-eval addressing + +**Goal.** Eliminate the last big string-dispatch site in Tier B: +`indexed_evals_by_prefix_any(evals, "stage6.booleanity.eval.InstructionRa_")` +and friends. Replace with a typed eval-family vocabulary. + +### The problem today + +Stage 6/7 evaluators do: + +```rust +let booleanity_evals = + indexed_evals_by_prefix_any(evals, "stage6.booleanity.eval.InstructionRa_")?; +``` + +This works because the prover emits evals named `..._0, ..._1, ..._2` and +the verifier wants them as `Vec`. The verifier reconstructs the family +by string-prefix matching plus integer-suffix parsing. This is the *only* +remaining "execution-relevant string dispatch" that the current +`verifier_cleanup` gates do not yet enforce-to-zero. + +### Dialect changes + +Extend `compute::sumcheck_eval` with an `eval_family` attribute (or add a +sibling `compute::sumcheck_eval_family` op): + +```mlir +compute.sumcheck_eval_family { + sym_name = "stage6.booleanity.instruction_ra_family" + produced_by = @stage6_booleanity_driver + oracle_family = "InstructionRa" + count = 3 +} -> %eval_vec : !field_vector +``` + +The existing `compute::sumcheck_eval` ops with names like +`...InstructionRa_0`, `...InstructionRa_1`, ... are replaced by a single +family op when the consumer needs the block as a vector. The prover side +already emits these as a contiguous block; the verifier side gains a typed +`!field_vector` handle to the whole block. + +### Runtime additions + +Add `EvalFamilyPlan` to `bolt-verifier-runtime`: + +```rust +pub struct EvalFamilyPlan { + pub symbol: &'static str, + pub source: &'static str, // sumcheck driver symbol + pub oracle_family: &'static str, // diagnostic + pub count: usize, +} +``` + +`ValueStore` learns to materialize a `FieldVector` value for family symbols +when the parent sumcheck output is observed. Consumers ask for a typed vector, +not a set of scalars recovered by prefix matching. + +### Tier B impact + +Each `expected_stage67_*` that today calls `indexed_evals_by_prefix_any` +instead reads a typed `&[Fr]` from the store. Estimated ~60 LOC reduction +in Tier B. + +### Blockers and complications + +- **Proof format.** The proof's `evals` field is already + `Vec>` with explicit `name` strings (verified in + `verifier_common.rs.template:393-397`). S4 changes how the *verifier + consumes* named evals, not how they are serialized. No back-compat + break. *This was the biggest risk; it is not real.* +- **Prover/verifier symmetry.** The prover-side emitter must annotate the + same eval block as a family. If this is a separate emitter, both must be + updated together. +- **`indexed_evals_by_prefix` and `indexed_evals_by_prefix_any` removal.** + These two helpers in Tier A become unused after S4. They can be deleted + from `bolt-verifier-runtime` to keep the API surface minimal. +- **Testing.** Add a `verifier_cleanup` gate + `RELATION_INDEXED_EVAL_PREFIX_SITES_CEILING = 0` that fires if any + generated stage source still calls `indexed_evals_by_prefix*`. + +### Acceptance criteria + +`muldiv` passes in both modes. Zero `indexed_evals_by_prefix*` call sites +in the generated verifier. Tier B drops to ~350 LOC. + +### Rollback + +Pure refactor. Roll back by reverting the eval-family slice. Do not keep +`indexed_evals_by_prefix_any` in the runtime as a verifier fallback once the +typed family path lands; that would leave two execution paths and weaken the +full-cutover guarantee. + +### Estimated wall-clock + +One agent session, 60-90 minutes. + +--- + +## S5: Relations as typed plan data + +**Goal.** Make the Stage 6/7 relation evaluators (`expected_stage67_*`) +declarative MLIR-derived plans rather than hand-written Rust functions. +After S5, the only thing left in Tier B is the bytecode-row encoding +(addressed by S6). + +### The shape + +After S3 + S4, every `expected_stage67_*` body is structurally: + +```text +val = Σ_i γ^i · (Π_j eq_mle(P_ij, query_point) · eval_k_ij) + boundary_terms +``` + +That is a flat algebraic expression DAG over plan operands. The preferred +abstraction is not a separate relation-expression language; it is a relation +metadata record pointing at a scalar value produced by the typed verifier value +graph introduced in S3/S4: + +```rust +pub struct RelationPlan { + pub symbol: &'static str, + pub stage: &'static str, + pub kind: RelationId, + pub query_point: &'static str, + pub expected_output: &'static str, // scalar produced by value graph +} +``` + +The runtime gains a generic `evaluate_relation_plan(plan, store) -> Fr` that +only resolves the typed `expected_output` value and applies relation-level +diagnostics/error mapping. The algebra itself should already be visible as +scalar/point/vector plan rows. Introduce a separate `RelationTerm` enum only if +the value graph cannot express a relation without contortions, and document why +that second interpreter is worth the extra audit surface. + +### Dialect changes + +Add a top-level `compute::relation` op that ties a relation kind to a typed +expected-output scalar: + +```mlir +compute.relation { + sym_name = "stage6.booleanity" + kind = "Stage6Booleanity" + query_point = @stage6_booleanity_point + expected_output = @stage6_booleanity_expected +} +``` + +Stage emitters lower this to a `RelationPlan` in the generated stage files. +The expression feeding `expected_output` should be ordinary typed value-graph +data, not hidden inside the emitter. + +### Tier C impact (acknowledged growth) + +The relation plans and their supporting scalar/point/vector value rows live in +the *generated* stage Rust, not in the runtime. Stage 6/7 will grow by an +estimated ~200 LOC of relation/value tables. This is the explicit trade: Tier B +shrinks by ~200 LOC and Tier C grows by ~200, but Tier C is declarative data +(audit-easy) while Tier B is hand-written Rust (audit-hard). + +The `GENERATED_VERIFIER_TARGET_LOC` ceiling will need to bump from 6,100 to +~6,300. That is OK provided the structure of stage files becomes more +declarative. + +### Blockers and complications + +- **Expressiveness limit.** The typed value graph must express every algebraic + shape that the Stage 6/7 relations currently use. Today's shapes are + uniform; future relations may not be. If Bolt acquires a new protocol with + relations that have control flow (e.g., conditional structure based on entry + data), extend the value graph or add a carefully-scoped relation interpreter + rather than escaping into generated helper functions. +- **Bytecode-read-RAF special case.** The bytecode-read-RAF evaluator has + a `for index in 0..stage_value_evals.len()` loop with a per-index + `int_contrib` mask. Model the loop as a value-graph reduction over a static + row table, but keep the mask values in the bytecode-encoding plan because + they are Jolt-specific (S6 territory). For S5, the relation consumes the + resulting scalar or vector as an opaque typed value; the relation metadata + itself stays generic. +- **Performance.** The verifier-side value graph walks a small DAG. We expect + zero perf concern. Keep a smoke benchmark anyway since this code runs once + per Stage 6/7 sumcheck instance. +- **Audit story.** Tier B drops to ~290 LOC, almost all of which is the + bytecode encoder. We should explicitly document in `GOAL.md` that the + relation algebra is *no longer* part of the audit surface; only the + generic interpreter (in `bolt-verifier-runtime`) and the bytecode + encoder are. + +### Acceptance criteria + +Same correctness gates plus: `expected_stage67_*` functions in Tier B +are deleted. New `compute::relation` ops and any value-graph ops they depend on +have validator coverage. `muldiv` passes in both modes. + +### Rollback + +This is the most invasive slice. If the relation interpreter design is +wrong, S5 should be revertible by restoring the deleted +`expected_stage67_*` functions and removing the relation-plan emitter +output. Recommend keeping the per-relation hand-written code in a +preserved-for-comparison file in the worklog while S5 is being shaken +down. + +### Estimated wall-clock + +Three to four agent sessions, ~6 hours of agent runtime in total. Highest +risk slice in this plan. + +--- + +## S6: Bytecode encoding as typed plan data (optional) + +**Goal.** Capture the Jolt-specific bytecode-row encoding rules as a +typed table rather than hand-written Rust. After S6, Tier B is ~50 LOC +and is essentially just `Stage67BytecodeEntry` (the data table itself, +not the math). + +### The encoding today + +`stage67_bytecode_entry_stage_values` decomposes a bytecode row into 5 +gamma-weighted sums (one per Stage 1-5). The pattern for each stage: + +```rust +let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1]; +for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) { + if *flag { stage1 += *gamma; } +} +``` + +This is a small DSL for "for each entry field, conditionally add a +gamma-weighted contribution." The fields and their conditions vary per +stage but the *shape* is uniform. + +### Capture as data + +```rust +pub struct BytecodeEncodingPlan { + pub stage_terms: [&'static [BytecodeTerm]; 5], +} + +pub enum BytecodeTerm { + Address { gamma_index: usize }, + Imm { gamma_index: usize }, + CircuitFlag { index: usize, gamma_index: usize }, + EntryFlag { which: BytecodeFlag, gamma_index: usize }, + RegisterEq { which: RegisterRole, gamma_index: usize }, + LookupTableIndex { offset: usize, gamma_base: usize }, +} + +pub enum BytecodeFlag { IsInterleaved, IsBranch, IsNoop, LeftIsRs1, ... } +pub enum RegisterRole { Rd, Rs1, Rs2 } +``` + +The runtime gains `evaluate_bytecode_encoding(entries, plan, gamma_powers, +register_points) -> [Fr; 5]`. Tier B keeps only the +`Stage67BytecodeEntry` trait and the per-stage `Stage6BytecodeEntry` / +`Stage7BytecodeEntry` impls (~50 LOC). + +### Dialect changes + +Optional: a `bytecode.encoding_plan` op family in a new `bytecode.mlir` +sub-dialect, OR keep `BytecodeEncodingPlan` purely as runtime-side data +that the Bolt emitter populates from a small declarative source. Lean: +declarative source first, dialect later if a second protocol uses the +same shape. + +### Blockers and complications + +- **Protocol-specificity.** This encoding is genuinely Jolt-specific. If + Bolt only ever has one protocol with this exact shape, S6 is overkill + and we should leave Tier B at ~290 LOC of typed Rust. +- **Lookup-table indexing.** `stage5 += stage5_gamma_powers[2 + table];` + is a *variable-index* contribution where the index depends on entry + data. The plan vocabulary must support this (`LookupTableIndex` above + handles it). +- **Conditional terms.** `if entry.is_interleaved() { ... }` becomes + `BytecodeTerm::EntryFlag { which: IsInterleaved, ... }`. Mechanical. +- **Audit win is small.** The remaining 290 LOC of bytecode encoding is + *already* easy to audit; it is a flat sequence of "if flag then add + gamma^k" lines. The audit benefit of S6 is lower than S2-S5. + +### Recommendation + +**Skip S6 unless** Bolt acquires a second protocol that wants the same +encoding shape. The 290 LOC of typed bytecode-encoding Rust is acceptable +audit surface as long as it is well-organized and tested. Mark S6 as +"optional follow-up; revisit when there is a second user." + +### Estimated wall-clock + +If pursued: two agent sessions, ~3 hours. Otherwise zero. + +--- + +## Cross-cutting concerns + +### Coordination with Markos' equivalence track + +Each slice that touches generated stage outputs (S2, S2.5, S3, S4, S5) will +require equivalence-side adapter updates in +`crates/jolt-equivalence/src/plan_adapters/generated_stage*.rs`. The +correct workflow is: + +1. Land the slice (compiler change + regenerated stage Rust + equivalence + adapter update) in one PR. +2. Stack on top of the most recent Markos tip + (`origin/jolt-v2/equivalence` today). +3. Do not split the slice across two PRs (one for compiler, one for + equivalence). The cross-crate type changes are too tightly coupled. + +If Markos pushes new commits to `jolt-v2/equivalence` while a slice is in +flight, the right move is `git rebase origin/jolt-v2/equivalence` and +re-run the full check matrix, not `git merge`. + +### Generic compiler vs Jolt-specific quarantine + +GOAL.md's "Locked Genericity Decisions" require that generic Bolt +compiler infrastructure not contain Jolt-specific code, and that Jolt +emitters be progressively lifted into generic CPU emitters. + +S2 strengthens this only if the extraction also corrects the protocol-ID +boundary. A crate named `bolt-verifier-runtime` should not permanently define +Jolt relation variants. Either make relation/stage identifiers generic or keep +the remaining Jolt vocabulary explicitly quarantined and gated until a follow-up +removes it. + +S3 + S4 are pure compute-dialect extensions; no Jolt content. They should add a +typed verifier value graph (`Scalar`, `Point`, `FieldVector`, eval families) +rather than a larger bag of scalar-only field-expression variants. + +S5 introduces `compute::relation` as generic relation metadata over the value +graph, not a Jolt-specific relation language. If a closed enum is useful for +readability, define it at the protocol/stage boundary and make the generic +runtime parameterized over it; otherwise use an opaque `RelationId` and keep +only diagnostic strings in the runtime. + +S6 is explicitly Jolt-specific. If pursued, it goes under +`crates/bolt/src/protocols/jolt/`, not in `bolt-verifier-runtime`. + +### Trust boundary and audit surface evolution + +The audit surface contracts as we move through the slices: + +```text +post-S1: Tier A (1,265 LOC) + Tier B (638 LOC) = 1,903 LOC audited +post-S2: bolt-runtime crate + Tier B (638 LOC) = ~1,900 LOC, but + Tier A is now + versioned and reviewed + once across protocols +post-S3: bolt-runtime crate + Tier B (~500 LOC) = ~1,750 LOC +post-S4: bolt-runtime crate + Tier B (~350 LOC) = ~1,600 LOC +post-S5: bolt-runtime crate + Tier B (~290 LOC) = ~1,540 LOC +post-S6: bolt-runtime crate + Tier B (~50 LOC) = ~1,300 LOC +``` + +The shape of the audit also changes: post-S5, almost all of Tier B is the +bytecode encoder, which is *data-table-shaped* hand-written Rust. That is +qualitatively easier to review than algebraic relation evaluators. + +### MLIR dialect growth + +`compute.mlir` is currently 808 lines. After S3 + S4 + S5 it will probably +land around 1,000-1,100 lines with the new poly, point-reordering, +pow-vector, eval-family, and relation ops. Still small enough to be one +dialect; no need for a `poly` or `relation` sub-dialect at that point. +Revisit if `compute.mlir` exceeds ~1,500 lines. + +### Performance + +Verifier perf is not the center of this track, but it is a non-regression +contract. The existing ignored `jolt-equivalence/tests/bolt_perf.rs` gates give +us real-data core-vs-Bolt setup/prove/verify/proof-size/RSS measurements, but +their current thresholds are broad smoke limits. Treat them as necessary but +not sufficient for interpreter-heavy slices. + +Before S2.5, S3, or S5 lands, record a local verifier-time baseline from the +SHA2-chain perf oracle and rerun it after the slice. If a verifier-time change +is noisy, rerun before calling it real. If a repeatable regression remains, +either fix it or explicitly document why the readability/security gain is worth +the cost. Do not loosen perf thresholds to make a refactor pass. + +The expected trend is "no measurable verifier change," because the interpreter +dispatches are straightforward and relation/value-graph evaluation happens a +small fixed number of times per verification. Any accidental +quadratic-in-trace-length loop is a blocker. + +### Compatibility with the `zk` feature + +All five slices are `cfg`-independent. They affect plan generation and +verifier interpretation, both of which are identical between the standard +and `zk` modes. Each slice must run `muldiv` in both +`--features host` and `--features host,zk` per the workspace's primary +correctness check. + +### Emitter discipline + +The Rust emitter should become a pretty-printer for typed plans, not the place +where verifier semantics are invented. Use these checks during every slice: + +- If emitted Rust contains a new helper function with protocol math, ask why + that helper is not a typed value-graph op or relation plan row. +- If the emitter parses or assembles meaning from a symbol string, add a typed + MLIR attr or plan field instead. +- If a runtime API accepts `&'static str` and branches on its contents, replace + it with a typed enum, typed symbol, or protocol-supplied ID. +- If two interpreters can evaluate the same verifier fact, delete one in the + same slice. +- If a generated table is too dense for blind review, improve the table shape + before counting the LOC reduction as a win. + +--- + +## Open questions + +These deserve human (Markos / Quang) input before S2 starts: + +1. **`bolt-verifier-runtime` location.** Standalone workspace crate under + `crates/bolt-verifier-runtime/`, or sub-crate of `bolt`? Recommend + standalone for versionability. +2. **`bolt-verifier-runtime` re-export through `bolt`.** Should `bolt` + re-export `bolt_verifier_runtime` for convenience, or keep them + separate? Recommend separate (stricter trust boundary). +3. **Per-stage type aliases.** Generated stage files contain + `pub type Stage6FieldExprPlan = FieldExprPlan` and ~20 similar aliases + per stage. Are these aliases load-bearing for downstream code (e.g., + `jolt-equivalence` adapters) or can they be deleted along with S2? + Spot-checking suggests they exist purely for readability and can go. +4. **Protocol relation IDs.** Should S2 parameterize runtime plan structs over + a protocol relation enum, or should it introduce an opaque `RelationId` / + `TypedPlanSymbol`? Lean: protocol enum for readability when a + stage matches on relation kind, opaque ID for generic runtime storage. + Either is better than putting Jolt variants in the generic runtime crate. +5. **Checkpoint naming.** What user-facing partial-verification checkpoints do + we want after S2.5? Lean: keep familiar names such as `ThroughStage5` only as + aliases for typed checkpoint constants while shifting internal execution to + proof slots / verifier steps. +6. **Value graph granularity.** Should S3 implement the scalar/point/vector + value graph before any new polynomial op, or can it land as part of the same + PR? Lean: same PR if small, but stop and split if the value typing gets + noisy. +7. **S6 threshold.** Is "second protocol with bytecode-row encoding" + the right trigger to actually do S6, or is there a different + readability / audit reason to do it preemptively? + +--- + +## Sequencing decision tree + +```text +Resolve S2 protocol-ID shape. [before coding] + Choose generic relation enum parameterization or opaque RelationId. + +Land S2 first. [unconditional] + Re-baseline ceilings. + Delete old common path; no compatibility re-export. + +Land S2.5 next. [unconditional] + Make verifier.rs execute a typed verifier program. + Stages become proof-slot labels / diagnostic scopes, not control flow. + +Land S3 next. [unconditional] + Establish scalar/point/field-vector value graph. + Tier B should drop ~140 LOC. + +Decide on S4 vs Markos' next slice. [coordinate] + S4 is independent of Markos' work; either order is fine. + +Pause before S5. [explicit human review] + Decide whether the relation-as-data shape is right for Jolt's + current and likely-future relations. If yes, land S5. If not, + stop here; the verifier is in a defensible state with Tier B at + ~350 LOC of typed Rust. + +S6 only on demand. [optional] + Defer until there is a concrete second user or audit pressure. +``` + +--- + +This plan is the agent-side complement to GOAL.md's `Concrete Gates` and +`Iteration Algorithm`. Update both files together when a slice lands so +the goal definition and the implementation plan stay in sync. From 599071a81c45328a9540d56cf660aef8cecba200 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Wed, 13 May 2026 22:49:55 -0600 Subject: [PATCH 017/171] refactor(bolt): extract verifier runtime Move the generated verifier common runtime into a standalone bolt-verifier-runtime workspace crate and depend on it from the generated verifier surface. Genericize relation-bearing runtime plans over ProtocolRelation, move JoltRelationKind into the Jolt verifier layer, and make Stage 8 own its temporary source-stage enum. Delete the generated stages/common.rs module and old verifier_common template, then update emitters, goldens, equivalence adapters, and cleanup gates for the full cutover. --- Cargo.lock | 13 + Cargo.toml | 2 + crates/bolt-verifier-runtime/Cargo.toml | 17 + .../src/lib.rs} | 104 +- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 292 ++-- crates/bolt/src/protocols/jolt/artifacts.rs | 19 +- .../src/protocols/jolt/emit/rust/stage1.rs | 29 +- .../src/protocols/jolt/emit/rust/stage2.rs | 39 +- .../src/protocols/jolt/emit/rust/stage3.rs | 77 +- .../src/protocols/jolt/emit/rust/stage4.rs | 60 +- .../src/protocols/jolt/emit/rust/stage5.rs | 68 +- .../src/protocols/jolt/emit/rust/stage6.rs | 61 +- .../src/protocols/jolt/emit/rust/stage7.rs | 57 +- .../src/protocols/jolt/emit/rust/stage8.rs | 5 +- .../jolt/verifier_jolt_relations.rs.template | 16 +- crates/bolt/tests/commitment_ir.rs | 69 +- crates/bolt/tests/verifier_cleanup.rs | 22 +- crates/jolt-equivalence/Cargo.toml | 1 + crates/jolt-equivalence/src/plan_adapters.rs | 114 +- crates/jolt-verifier/Cargo.toml | 1 + crates/jolt-verifier/src/stages/common.rs | 1265 ----------------- .../src/stages/jolt_relations.rs | 16 +- crates/jolt-verifier/src/stages/mod.rs | 1 - .../jolt-verifier/src/stages/stage1_outer.rs | 27 +- crates/jolt-verifier/src/stages/stage2.rs | 39 +- crates/jolt-verifier/src/stages/stage3.rs | 75 +- crates/jolt-verifier/src/stages/stage4.rs | 60 +- crates/jolt-verifier/src/stages/stage5.rs | 68 +- crates/jolt-verifier/src/stages/stage6.rs | 61 +- crates/jolt-verifier/src/stages/stage7.rs | 57 +- crates/jolt-verifier/src/stages/stage8.rs | 17 +- crates/jolt-verifier/src/verifier.rs | 12 +- 32 files changed, 819 insertions(+), 1945 deletions(-) create mode 100644 crates/bolt-verifier-runtime/Cargo.toml rename crates/{bolt/src/protocols/jolt/verifier_common.rs.template => bolt-verifier-runtime/src/lib.rs} (91%) delete mode 100644 crates/jolt-verifier/src/stages/common.rs diff --git a/Cargo.lock b/Cargo.lock index f48897ce2b..312ab1d537 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1102,6 +1102,17 @@ dependencies = [ "melior", ] +[[package]] +name = "bolt-verifier-runtime" +version = "0.1.0" +dependencies = [ + "jolt-field", + "jolt-poly", + "jolt-sumcheck", + "jolt-transcript", + "serde", +] + [[package]] name = "borsh" version = "1.6.0" @@ -2902,6 +2913,7 @@ dependencies = [ "ark-bn254", "ark-serialize 0.5.0", "bolt", + "bolt-verifier-runtime", "common", "jolt-core", "jolt-dory", @@ -3322,6 +3334,7 @@ dependencies = [ name = "jolt-verifier" version = "0.0.0" dependencies = [ + "bolt-verifier-runtime", "jolt-dory", "jolt-field", "jolt-lookup-tables", diff --git a/Cargo.toml b/Cargo.toml index 3fc0ac5db7..d37ea39a9b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -41,6 +41,7 @@ members = [ "crates/jolt-prover", "crates/jolt-verifier", "crates/jolt-equivalence", + "crates/bolt-verifier-runtime", "crates/jolt-profiling", "crates/jolt-field", "jolt-core", @@ -393,6 +394,7 @@ jolt-sumcheck = { path = "./crates/jolt-sumcheck" } jolt-r1cs = { path = "./crates/jolt-r1cs" } jolt-witness = { path = "./crates/jolt-witness" } bolt = { path = "./crates/bolt" } +bolt-verifier-runtime = { path = "./crates/bolt-verifier-runtime" } jolt-kernels = { path = "./crates/jolt-kernels" } jolt-prover = { path = "./crates/jolt-prover" } jolt-verifier = { path = "./crates/jolt-verifier" } diff --git a/crates/bolt-verifier-runtime/Cargo.toml b/crates/bolt-verifier-runtime/Cargo.toml new file mode 100644 index 0000000000..c1c361fb1b --- /dev/null +++ b/crates/bolt-verifier-runtime/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "bolt-verifier-runtime" +version = "0.1.0" +edition = "2021" +license = "MIT OR Apache-2.0" +description = "Protocol-generic runtime helpers for Bolt-generated verifier crates" +repository = "https://github.com/a16z/jolt" + +[lints] +workspace = true + +[dependencies] +jolt-field.workspace = true +jolt-poly.workspace = true +jolt-sumcheck.workspace = true +jolt-transcript.workspace = true +serde.workspace = true diff --git a/crates/bolt/src/protocols/jolt/verifier_common.rs.template b/crates/bolt-verifier-runtime/src/lib.rs similarity index 91% rename from crates/bolt/src/protocols/jolt/verifier_common.rs.template rename to crates/bolt-verifier-runtime/src/lib.rs index a5883c82ee..18f98925f8 100644 --- a/crates/bolt/src/protocols/jolt/verifier_common.rs.template +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -58,9 +58,9 @@ pub struct KernelPlan { pub abi: &'static str, } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -#[rustfmt::skip] -pub enum RelationKind { Stage1OuterUniskip, Stage1OuterRemaining, Stage2ProductVirtualUniskip, Stage2RamReadWrite, Stage2ProductVirtualRemainder, Stage2InstructionLookupClaimReduction, Stage2RamRafEvaluation, Stage2RamOutputCheck, Stage2Batched, Stage3SpartanShift, Stage3InstructionInput, Stage3RegistersClaimReduction, Stage3Batched, Stage4RegistersReadWrite, Stage4RamValCheck, Stage4Batched, Stage5InstructionReadRaf, Stage5RamRaClaimReduction, Stage5RegistersValEvaluation, Stage5Batched, Stage6BytecodeReadRaf, Stage6Booleanity, Stage6HammingBooleanity, Stage6RamRaVirtual, Stage6InstructionRaVirtual, Stage6IncClaimReduction, Stage6Batched, Stage7HammingWeightClaimReduction, Stage7Batched } +pub trait ProtocolRelation: Copy + Eq + fmt::Debug + 'static {} + +impl ProtocolRelation for T {} #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum TranscriptSqueezeKind { @@ -109,21 +109,6 @@ pub enum ClaimKind { Virtual, } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum SourceStage { - Stage6, - Stage7, -} - -impl SourceStage { - pub fn as_str(self) -> &'static str { - match self { - Self::Stage6 => "stage6", - Self::Stage7 => "stage7", - } - } -} - #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum PcsProofMode { Open, @@ -167,7 +152,7 @@ pub struct FieldExprPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckClaimPlan { +pub struct SumcheckClaimPlan { pub symbol: &'static str, pub stage: &'static str, pub domain: &'static str, @@ -175,7 +160,7 @@ pub struct SumcheckClaimPlan { pub degree: usize, pub claim: &'static str, pub kernel: Option<&'static str>, - pub relation: Option, + pub relation: Option, pub claim_value: &'static str, } @@ -193,12 +178,12 @@ pub struct SumcheckBatchPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckDriverPlan { +pub struct SumcheckDriverPlan { pub symbol: &'static str, pub stage: &'static str, pub proof_slot: &'static str, pub kernel: Option<&'static str>, - pub relation: Option, + pub relation: Option, pub batch: &'static str, pub policy: &'static str, pub round_schedule: &'static [usize], @@ -209,11 +194,11 @@ pub struct SumcheckDriverPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckInstanceResultPlan { +pub struct SumcheckInstanceResultPlan { pub symbol: &'static str, pub source: &'static str, pub claim: &'static str, - pub relation: RelationKind, + pub relation: R, pub index: usize, pub point_arity: usize, pub num_rounds: usize, @@ -291,7 +276,7 @@ pub struct OpeningBatchPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageProgramPlan { +pub struct StageProgramPlan { pub role: &'static str, pub params: StageParams, pub steps: &'static [ProgramStepPlan], @@ -301,10 +286,10 @@ pub struct StageProgramPlan { pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], pub kernels: &'static [KernelPlan], - pub claims: &'static [SumcheckClaimPlan], + pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], + pub drivers: &'static [SumcheckDriverPlan], + pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], pub point_zeros: &'static [PointZeroPlan], pub point_slices: &'static [PointSlicePlan], @@ -315,7 +300,7 @@ pub struct StageProgramPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageProgramPlanNoPointZeros { +pub struct StageProgramPlanNoPointZeros { pub role: &'static str, pub params: StageParams, pub steps: &'static [ProgramStepPlan], @@ -325,10 +310,10 @@ pub struct StageProgramPlanNoPointZeros { pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], pub kernels: &'static [KernelPlan], - pub claims: &'static [SumcheckClaimPlan], + pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], + pub drivers: &'static [SumcheckDriverPlan], + pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], @@ -338,17 +323,17 @@ pub struct StageProgramPlanNoPointZeros { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageVerifierProgramPlan { +pub struct StageVerifierProgramPlan { pub params: StageParams, pub steps: &'static [ProgramStepPlan], pub transcript_squeezes: &'static [TranscriptSqueezePlan], pub opening_inputs: &'static [OpeningInputPlan], pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], - pub claims: &'static [SumcheckClaimPlan], + pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], + pub drivers: &'static [SumcheckDriverPlan], + pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], @@ -358,17 +343,17 @@ pub struct StageVerifierProgramPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageVerifierProgramPlanNoEqualities { +pub struct StageVerifierProgramPlanNoEqualities { pub params: StageParams, pub steps: &'static [ProgramStepPlan], pub transcript_squeezes: &'static [TranscriptSqueezePlan], pub opening_inputs: &'static [OpeningInputPlan], pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], - pub claims: &'static [SumcheckClaimPlan], + pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], + pub drivers: &'static [SumcheckDriverPlan], + pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], @@ -377,13 +362,13 @@ pub struct StageVerifierProgramPlanNoEqualities { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct VerifierProgramPlanMinimal { +pub struct VerifierProgramPlanMinimal { pub params: StageParams, pub transcript_squeezes: &'static [TranscriptSqueezePlan], - pub claims: &'static [SumcheckClaimPlan], + pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], + pub drivers: &'static [SumcheckDriverPlan], + pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], pub opening_claims: &'static [OpeningClaimPlan], pub opening_batches: &'static [OpeningBatchPlan], @@ -463,21 +448,22 @@ pub enum RuntimePlanError { }, } +#[macro_export] macro_rules! impl_runtime_plan_error_conversion { ($error:ident) => { - impl From for $error { - fn from(error: super::common::RuntimePlanError) -> Self { + impl From<$crate::RuntimePlanError> for $error { + fn from(error: $crate::RuntimePlanError) -> Self { match error { - super::common::RuntimePlanError::MissingBatch { driver, batch } => { + $crate::RuntimePlanError::MissingBatch { driver, batch } => { Self::MissingBatch { driver, batch } } - super::common::RuntimePlanError::MissingClaim { batch, claim } => { + $crate::RuntimePlanError::MissingClaim { batch, claim } => { Self::MissingClaim { batch, claim } } - super::common::RuntimePlanError::MissingValue { symbol } => { + $crate::RuntimePlanError::MissingValue { symbol } => { Self::MissingValue { symbol } } - super::common::RuntimePlanError::InvalidInputLength { + $crate::RuntimePlanError::InvalidInputLength { input, expected, actual, @@ -486,7 +472,7 @@ macro_rules! impl_runtime_plan_error_conversion { expected, actual, }, - super::common::RuntimePlanError::InvalidProof { driver, reason } => { + $crate::RuntimePlanError::InvalidProof { driver, reason } => { Self::InvalidProof { driver, reason } } } @@ -495,8 +481,6 @@ macro_rules! impl_runtime_plan_error_conversion { }; } -pub(crate) use impl_runtime_plan_error_conversion; - pub trait SymbolPlan { fn symbol(&self) -> &'static str; } @@ -519,13 +503,13 @@ impl SymbolPlan for SumcheckBatchPlan { } } -impl SymbolPlan for SumcheckClaimPlan { +impl SymbolPlan for SumcheckClaimPlan { fn symbol(&self) -> &'static str { self.symbol } } -impl SymbolPlan for SumcheckDriverPlan { +impl SymbolPlan for SumcheckDriverPlan { fn symbol(&self) -> &'static str { self.symbol } @@ -542,7 +526,7 @@ pub trait SumcheckClaimInfo: SymbolPlan { fn claim_value(&self) -> &'static str; } -impl SumcheckClaimInfo for SumcheckClaimPlan { +impl SumcheckClaimInfo for SumcheckClaimPlan { fn num_rounds(&self) -> usize { self.num_rounds } @@ -559,7 +543,7 @@ pub trait SumcheckDriverInfo: SymbolPlan { fn round_label(&self) -> &'static str; } -impl SumcheckDriverInfo for SumcheckDriverPlan { +impl SumcheckDriverInfo for SumcheckDriverPlan { fn batch(&self) -> &'static str { self.batch } @@ -653,12 +637,12 @@ impl ValueStore { Ok(()) } - pub fn observe_sumcheck_output( + pub fn observe_sumcheck_output( &mut self, - instance_results: &[SumcheckInstanceResultPlan], + instance_results: &[SumcheckInstanceResultPlan], evals: &[SumcheckEvalPlan], output: &StageSumcheckOutput, - normalize_point: impl Fn(&SumcheckInstanceResultPlan, Vec) -> Result, E>, + normalize_point: impl Fn(&SumcheckInstanceResultPlan, Vec) -> Result, E>, invalid_input_length: impl Fn(&'static str, usize, usize) -> E, missing_value: impl Fn(&'static str) -> E, ) -> Result<(), E> { diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index baf1132029..6ca08d72dc 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -156,7 +156,7 @@ an explicit decision, or weaker semantically. | post-S1 (today) | 1,265 | 638 | 6,430 | 7,905 | hard ceilings: A 1,400 / B 700 / C surface 6,100 | | post-S2 | ~50 | 638 | 6,430 | ~6,640 | Tier A moves to `bolt-verifier-runtime` crate | | post-S2.5 | ~150-250 | 638 | ~6,200 | ~6,900 | top-level verifier executes a typed verifier program | -| post-S3 | ~50 | ~500 | 6,430 | ~6,500 | poly, point reordering, gamma-power vector ops | +| post-S3 | ~50 | <=638 | ~6,300-6,500 | ~6,500 | value graph foundation + first Stage 3/4 relation plans | | post-S4 | ~50 | ~350 | 6,500 | ~6,500 | typed indexed-eval addressing | | post-S5 | ~50 | ~290 | 6,700 | ~6,700 | relations as typed plans (Tier C grows) | | post-S6 | ~50 | ~50 | 6,800 | ~6,800 | bytecode encoding as typed plans (optional) | @@ -183,6 +183,48 @@ as proof that the runtime is already pure generic infrastructure. Once Tier A is a real crate with an explicit public API, every subsequent slice operates against a stable, versionable surface. +### Locked decisions + +- `bolt-verifier-runtime` is a standalone workspace crate at + `crates/bolt-verifier-runtime/`. It is not a sub-crate of `bolt` and is not + re-exported through `bolt`. +- Relation IDs use generic enum parameterization, not opaque string-backed + symbols. Relations are used for verifier dispatch, so a closed protocol enum + gives exhaustive-match pressure and keeps strings out of execution contracts. +- The generic runtime owns the relation trait and generic plan structs. The + Jolt layer owns the closed relation enum: + + ```rust + pub trait ProtocolRelation: Copy + Eq + core::fmt::Debug + 'static {} + impl ProtocolRelation for T {} + + pub struct SumcheckClaimPlan { + pub relation: Option, + // ... + } + + pub struct SumcheckDriverPlan { + pub relation: Option, + // ... + } + + pub struct SumcheckInstanceResultPlan { + pub relation: R, + // ... + } + ``` + + `JoltRelationKind` lives in the generated Jolt verifier's + `jolt_relations` module, and stage files alias it as + `StageNRelationKind`. `TypedPlanSymbol` remains useful for value, + opening, claim, and diagnostic symbols, but not for relation dispatch. +- `SourceStage` is not part of the generic runtime. Stage 8 gets a local + `Stage8SourceStage` enum until the later PCS-opening plan model removes the + source-stage special case entirely. +- Per-stage type aliases are not load-bearing. Keep or delete them based on + readability after the import cutover, but do not preserve them as API + compatibility shims. + ### Concrete plumbing 1. New crate `crates/bolt-verifier-runtime/` with `src/lib.rs` seeded from @@ -209,13 +251,12 @@ against a stable, versionable surface. 7. `crates/jolt-equivalence/src/plan_adapters/generated_stage*.rs` and the oracle modules update their `use jolt_verifier::stages::common::*` imports to `use bolt_verifier_runtime::*`. -8. Decide and implement the protocol-ID boundary. Preferred: make runtime plan - structs generic over a protocol relation enum, or carry an opaque - `RelationId`/`TypedPlanSymbol` that is defined by the protocol - layer. Avoid defining Jolt relation variants in `bolt-verifier-runtime`. - If this makes S2 too large, split it into S2a extraction and S2b - protocol-ID cleanup before starting S3, and keep the temporary ownership - debt gated. +8. Move `RelationKind` out of Tier A and into the Jolt layer as + `JoltRelationKind`. Genericize relation-bearing runtime structs over + `R: ProtocolRelation`. +9. Move `SourceStage` out of Tier A. Stage 8 defines a local source-stage enum + until S2.5/S4/S5 replace that source lookup with typed verifier-program / + opening-batch data. ### Test/gate updates @@ -236,10 +277,9 @@ against a stable, versionable surface. must move to `bolt_verifier_runtime` in the same PR. Mechanical, but large. - **Genericity debt.** `RelationKind` and `SourceStage` are the current - strongest evidence that Tier A is not purely generic. Do not quietly move - those names into a crate called `bolt-verifier-runtime` and declare the - boundary clean. Either genericize them in S2 or document the exact remaining - ownership debt with a follow-up gate. + strongest evidence that Tier A is not purely generic. S2 must remove both + from the runtime boundary. Do not split this into an extraction-only PR that + leaves Jolt relation variants in `bolt-verifier-runtime`. - **Type aliases in stage files.** Generated stage files contain `pub type Stage6FieldExprPlan = FieldExprPlan;` and similar. After S2 the right-hand side is `bolt_verifier_runtime::FieldExprPlan`. The @@ -282,8 +322,10 @@ is harmless) or be deleted. No data or proof-format changes are involved. ### Estimated wall-clock -One agent session, 60-90 minutes. The work is mechanical but touches many -files because of the cross-crate import changes. +One overnight implementation block. The code movement is mechanical, but it +touches enough emitters, generated artifacts, tests, and equivalence adapters +that the verification matrix should be allowed to run after the import churn is +settled. --- @@ -301,14 +343,44 @@ flow. ### Concrete plumbing -1. Add shared runtime types: +1. Add typed top-level verifier-program types: ```rust - VerifierProgramPlan - VerifierStepPlan - ProofSlot - VerifierCheckpoint - ArtifactStore + pub enum ProofSlot { + Commitments, + Stage1Outer, + Stage2, + Stage3, + Stage4, + Stage5, + Stage6, + Stage7, + Evaluation, + } + + pub enum VerifierStepPlan { + ReceiveCommitments { slot: ProofSlot }, + VerifyStage { slot: ProofSlot }, + VerifyPcsOpening { slot: ProofSlot }, + } + + pub enum VerifierCheckpoint { + AfterStage5, + AfterStage6, + AfterStage7, + AfterEvaluation, + } + + pub enum EvaluationPolicy { + Skip, + VerifyIfPresent, + Required, + } + + pub struct VerifierTarget { + pub checkpoint: VerifierCheckpoint, + pub evaluation: EvaluationPolicy, + } ``` `ProofSlot` is the protocol/proof-layout identity. `VerifierStepPlan` is the @@ -316,19 +388,26 @@ flow. 2. Represent commitment receipt, transcript absorbs/squeezes, sumcheck driver verification, opening-batch emission, and PCS opening verification as program steps. -3. Replace the hardcoded stage call chain in `verifier.rs` with a loop over the - generated program. Existing `verify_stageN_with_program` functions can be - used as step executors during this slice, but there must be one execution - path, not old/manual and new/program paths side by side. -4. Replace target APIs such as `through_stage5`, `through_stage6`, and +3. Keep `JoltProof` serialization unchanged: + `commitments`, `stage1_outer`, `stage2`, ..., `stage7`, `evaluation`. + The verifier program is execution metadata, not proof data. +4. Replace the hardcoded stage call chain in `verifier.rs` with a loop over the + generated program. Existing `verify_stageN_with_program` functions remain as + slot executors during this slice, but there must be one execution path, not + old/manual and new/program paths side by side. +5. Replace target APIs such as `through_stage5`, `through_stage6`, and `through_stage7` with named checkpoints or proof-slot targets. The old names can survive as user-facing constructors only if they are constants for the new checkpoint values, not separate branches. -5. Make stage artifacts addressable through `ArtifactStore` keyed by typed - proof slots / claim IDs rather than Rust fields that assume a permanent - number of stages. -6. Stage 8 becomes `VerifyPcsOpening { check }` plus supporting opening-batch +6. Make stage artifacts addressable through an internal `ArtifactStore` keyed by + typed proof slots. Public `JoltVerificationArtifacts` keeps its current field + shape for this slice and is materialized from the store at the end so + downstream callers are not forced to migrate yet. +7. Stage 8 becomes `VerifyPcsOpening { check }` plus supporting opening-batch plans. It should not be special because it happens to be the eighth module. +8. Keep stage-local error quality. Stage failures still map to + `JoltVerifyError::StageN`; only structural verifier-program failures use a + new top-level program error. ### Acceptance criteria @@ -341,6 +420,8 @@ flow. - Partial verification targets are typed checkpoints/proof slots. - No duplicate old/new verifier execution path remains. - Existing semantic, tamper, and import gates still pass. +- A before/after verifier-time perf baseline is captured before landing this + slice, because it changes top-level execution structure. ### Blockers and complications @@ -357,19 +438,23 @@ flow. ### Estimated wall-clock Two to three agent sessions. This is mostly control-flow architecture and -artifact typing, not new protocol math. +artifact typing, not new protocol math. It should be run after S2 and after +capturing the perf baseline. --- ## S3: Typed verifier value graph + polynomial primitives -**Goal.** Lift the small set of pure-dataflow primitives in Tier B into a -typed verifier value graph, backed by MLIR ops. Tier B's relation evaluators -stop calling `EqPolynomial::mle`, `bytecode_gamma_powers`, `field_powers`, -`reverse_slice`, `prefix_point`, `suffix_point`, and the `normalize_*_point` -helpers directly. The important design point is that this is not "add more -variants to `FieldExprKind`"; it is a typed graph over scalar, point, and -field-vector values. +**Goal.** Introduce the typed verifier value graph and use it for the first +relation-output checks. This is broader than Stage 6/7 helper cleanup: stages +2-7 all contain handwritten expected-output math. The first conversions should +be Stage 3 and Stage 4 because they exercise the value-graph path without RAM +external data, bytecode rows, lookup-table families, or univariate-skip proof +shape. + +The important design point is that this is not "add more variants to +`FieldExprKind`"; it is a typed graph over scalar, point, field-vector, and +eval-family values. ### Dialect changes @@ -414,6 +499,7 @@ pub enum VerifierValueKind { Scalar, Point, FieldVector, + EvalFamily, } pub enum ScalarExprKind { @@ -453,17 +539,33 @@ must be evaluated by the point interpreter and vector producers by the vector interpreter. This keeps the type boundary honest and prevents the runtime from becoming a bag of ad hoc helper functions. -### Tier B impact - -After S3, `verifier_jolt_relations.rs.template` no longer defines: -`bytecode_gamma_powers`, `field_powers`, `reverse_slice`, `prefix_point`, -`suffix_point`, `indexed_boolean_eq`, `normalize_bytecode_read_raf_point`, -`normalize_instruction_read_raf_point`, `operand_polynomial_eval`, -`identity_polynomial_eval`, `lt_polynomial_eval`. Total: ~140 LOC removed. - -The `expected_stage67_*` evaluators stay hand-written for now, but their -*bodies* shrink because the primitives they invoke are now provided by the -runtime. +### Locked conversion order + +1. Build the value-graph foundation: scalar, point, field-vector, and + eval-family storage and plan rows. +2. Convert Stage 3 expected-output checks first: + Spartan shift, instruction input, and registers claim reduction. +3. Convert Stage 4 next: + registers read-write, RAM val check, `lt` evaluation, suffix points, and + the Stage 4 register-read-write point normalization. +4. Convert the small Stage 5 relations next: + RAM RA claim reduction and registers val evaluation. +5. Convert Stage 2 in two parts: + RAM read-write / product remainder / instruction lookup first, then RAM RAF, + RAM output, and univariate-skip-specific logic later. +6. Convert Stage 6/7 family relations after eval-family support: + booleanity, hamming booleanity, RAM RA virtual, instruction RA virtual, inc + reduction, and Stage 7 hamming-weight reduction. +7. Defer S5 instruction read-RAF and S6 bytecode read-RAF until lookup-table, + bytecode-entry, and external-data domains are designed. + +### Deliberate deferrals + +Do not start S3 by designing generic bytecode-row algebra, RAM sparse +evaluators, lookup-table MLE plans, or univariate-skip verifier replacement. +Those are real verifier facts, but starting there would likely create a too +general mini-language before the scalar/point/vector graph has been validated +on simpler relations. ### Blockers and complications @@ -479,11 +581,9 @@ runtime. gamma-power vectors. Points are multilinear query coordinates; gamma powers are ordered scalar tuples. Conflating them would make later relation-plan typing harder and hide meaning from reviewers. -- **Stage emitter updates.** The Stage 6/7 emitters (the largest in - `crates/bolt/src/protocols/jolt/emit/rust/`) currently inline calls to - these helpers when building `expected_stage67_*` bodies. They must learn - to lower those call sites to `compute.poly_mle` etc. and let the - generic interpreter run them. +- **Stage emitter updates.** Stage 3/4 should be the first emitters to lower + relation-output math to value-graph rows. Stage 6/7 remain later consumers + once eval families and bytecode/external-data boundaries are clear. - **Validator updates.** Each new `compute::*` op needs an entry in the Bolt validator so malformed plans (wrong arity, wrong operand types) are rejected at compile time. @@ -491,10 +591,12 @@ runtime. ### Acceptance criteria `muldiv` e2e test passes in both `--features host` and `--features host,zk` -(this is the workspace's primary correctness check). Tier B drops to -~500 LOC. New metrics in `verifier_cleanup.rs`: -`compute_poly_op_call_sites`, `compute_point_op_call_sites` reported but -not gated yet. +(this is the workspace's primary correctness check). Stage 3 and Stage 4 +expected-output helper bodies are replaced by typed value-graph plan rows. New +metrics in `verifier_cleanup.rs`: `compute_poly_op_call_sites`, +`compute_point_op_call_sites`, `value_graph_relation_outputs`, and +`handwritten_expected_output_functions` reported. Gate only the Stage 3/4 +cutover in this slice; do not claim Stage 6/7 relation math is solved yet. ### Rollback @@ -842,10 +944,10 @@ typed verifier value graph (`Scalar`, `Point`, `FieldVector`, eval families) rather than a larger bag of scalar-only field-expression variants. S5 introduces `compute::relation` as generic relation metadata over the value -graph, not a Jolt-specific relation language. If a closed enum is useful for -readability, define it at the protocol/stage boundary and make the generic -runtime parameterized over it; otherwise use an opaque `RelationId` and keep -only diagnostic strings in the runtime. +graph, not a Jolt-specific relation language. Closed relation enums live at the +protocol/stage boundary; the generic runtime is parameterized over the protocol +relation enum when it needs equality or dispatch. Opaque typed symbols are for +generic storage paths that do not branch on relation kind. S6 is explicitly Jolt-specific. If pursued, it goes under `crates/bolt/src/protocols/jolt/`, not in `bolt-verifier-runtime`. @@ -923,57 +1025,53 @@ where verifier semantics are invented. Use these checks during every slice: --- -## Open questions - -These deserve human (Markos / Quang) input before S2 starts: - -1. **`bolt-verifier-runtime` location.** Standalone workspace crate under - `crates/bolt-verifier-runtime/`, or sub-crate of `bolt`? Recommend - standalone for versionability. -2. **`bolt-verifier-runtime` re-export through `bolt`.** Should `bolt` - re-export `bolt_verifier_runtime` for convenience, or keep them - separate? Recommend separate (stricter trust boundary). -3. **Per-stage type aliases.** Generated stage files contain - `pub type Stage6FieldExprPlan = FieldExprPlan` and ~20 similar aliases - per stage. Are these aliases load-bearing for downstream code (e.g., - `jolt-equivalence` adapters) or can they be deleted along with S2? - Spot-checking suggests they exist purely for readability and can go. -4. **Protocol relation IDs.** Should S2 parameterize runtime plan structs over - a protocol relation enum, or should it introduce an opaque `RelationId` / - `TypedPlanSymbol`? Lean: protocol enum for readability when a - stage matches on relation kind, opaque ID for generic runtime storage. - Either is better than putting Jolt variants in the generic runtime crate. -5. **Checkpoint naming.** What user-facing partial-verification checkpoints do - we want after S2.5? Lean: keep familiar names such as `ThroughStage5` only as - aliases for typed checkpoint constants while shifting internal execution to - proof slots / verifier steps. -6. **Value graph granularity.** Should S3 implement the scalar/point/vector - value graph before any new polynomial op, or can it land as part of the same - PR? Lean: same PR if small, but stop and split if the value typing gets - noisy. -7. **S6 threshold.** Is "second protocol with bytecode-row encoding" - the right trigger to actually do S6, or is there a different - readability / audit reason to do it preemptively? +## Locked sequencing decisions + +The investigation pass resolved the implementation choices that should not need +more user input before an overnight run: + +1. `bolt-verifier-runtime` is a standalone workspace crate, with no + `bolt::*` re-export. +2. Runtime relation-bearing plan structs are generic over `R: + ProtocolRelation`; Jolt relation variants live in `JoltRelationKind`. +3. Stage 8 source-stage handling is local to Stage 8 until the PCS/opening + model is made fully typed. +4. Legacy names such as `ThroughStage5` may remain as user-facing constructors, + but internally they resolve to `VerifierTarget { checkpoint, evaluation }`. +5. S2 does not need a perf baseline because it is import/extraction work. + S2.5, S3, and S5 do need before/after verifier-time baselines because they + add or change interpreter execution. +6. S3 starts with the value-graph foundation plus Stage 3/4 conversions. It + does not start with bytecode, RAM sparse evaluators, lookup-table MLEs, or + univariate-skip verifier replacement. +7. S6 remains optional and should be deferred unless there is a second protocol + user or concrete audit pressure for typed bytecode-row encoding. --- ## Sequencing decision tree ```text -Resolve S2 protocol-ID shape. [before coding] - Choose generic relation enum parameterization or opaque RelationId. - Land S2 first. [unconditional] + Extract Tier A to standalone bolt-verifier-runtime. + Genericize runtime relation-bearing plans over ProtocolRelation. + Move JoltRelationKind and Stage8SourceStage out of the runtime. Re-baseline ceilings. Delete old common path; no compatibility re-export. +Capture verifier perf baseline. [before interpreter changes] + Run SHA2-chain 2^16; run 2^20 if overnight budget allows. + Record verify_ms/proof_bytes/RSS and keep Perfetto traces. + Land S2.5 next. [unconditional] Make verifier.rs execute a typed verifier program. Stages become proof-slot labels / diagnostic scopes, not control flow. + Keep proof serialization and public artifact shape unchanged. Land S3 next. [unconditional] - Establish scalar/point/field-vector value graph. - Tier B should drop ~140 LOC. + Establish scalar/point/field-vector/eval-family value graph. + Convert Stage 3 then Stage 4 relation-output checks first. + Defer bytecode, RAM sparse, lookup-table, and univariate-skip special cases. Decide on S4 vs Markos' next slice. [coordinate] S4 is independent of Markos' work; either order is fine. diff --git a/crates/bolt/src/protocols/jolt/artifacts.rs b/crates/bolt/src/protocols/jolt/artifacts.rs index d136a05f44..7bff07f9d2 100644 --- a/crates/bolt/src/protocols/jolt/artifacts.rs +++ b/crates/bolt/src/protocols/jolt/artifacts.rs @@ -221,6 +221,7 @@ pub fn jolt_artifact_config() -> ProtocolArtifactConfig { "rayon".to_owned(), ], verifier_dependencies: vec![ + "bolt-verifier-runtime".to_owned(), "jolt-dory".to_owned(), "jolt-lookup-tables".to_owned(), "jolt-sumcheck".to_owned(), @@ -243,16 +244,6 @@ pub fn jolt_artifact_config() -> ProtocolArtifactConfig { prover_setup_type: RustTypeRef::new("jolt_dory::DoryProverSetup"), role_api_extension: Some(jolt_evaluation_role_api_extension()), verifier_runtime_modules: vec![ - // Tier A: generic Bolt verifier scaffolding (typed plan - // structs, ValueStore, generic sumcheck verification, generic - // field-expr dispatch). See crates/bolt/GOAL.md "Audit Tiers". - ProtocolRuntimeModule { - module_name: "common".to_owned(), - file: GeneratedFile { - path: "src/stages/common.rs".to_owned(), - source: include_str!("verifier_common.rs.template").to_owned(), - }, - }, // Tier B: audited Jolt verifier core (hand-written Stage 6/7 // relation evaluators, point normalizations, and Jolt-specific // field-math helpers). NOT generated. See crates/bolt/GOAL.md @@ -265,11 +256,11 @@ pub fn jolt_artifact_config() -> ProtocolArtifactConfig { }, }, ], - verifier_named_eval_type: RustTypeRef::new("crate::stages::common::StageNamedEval"), + verifier_named_eval_type: RustTypeRef::new("bolt_verifier_runtime::StageNamedEval"), verifier_sumcheck_output_type: RustTypeRef::new( - "crate::stages::common::StageSumcheckOutput", + "bolt_verifier_runtime::StageSumcheckOutput", ), - verifier_stage_proof_type: RustTypeRef::new("crate::stages::common::StageProof"), + verifier_stage_proof_type: RustTypeRef::new("bolt_verifier_runtime::StageProof"), } } @@ -375,7 +366,7 @@ fn jolt_evaluation_role_api_extension() -> ProtocolArtifactExtension { lib_module: jolt_verifier_lib_module(), imports: "use std::collections::BTreeMap;\n\nuse jolt_dory::{DoryCommitment, DoryProof, DoryScheme, DoryVerifierSetup};\nuse jolt_field::Fr;\nuse jolt_openings::{AdditivelyHomomorphic, CommitmentScheme, OpeningsError};\nuse jolt_poly::EqPolynomial;\nuse jolt_transcript::Transcript;\n".to_owned(), proof_fields: " pub evaluation: Option,\n".to_owned(), - proof_items: "pub type JoltStage2RamAccess = crate::stages::stage2::Stage2RamAccess;\npub type JoltStage2RamOutputLayout = crate::stages::stage2::Stage2RamOutputLayout;\npub type JoltStage2RamData<'a> = crate::stages::stage2::Stage2RamData<'a>;\npub type JoltStageChallengeVector = crate::stages::common::StageChallengeVector;\npub type JoltStageExecutionArtifacts = crate::stages::common::StageExecutionArtifacts;\npub type JoltStageOpeningInputValue = crate::stages::common::StageOpeningInputValue;\n\n#[derive(Clone, Debug)]\npub struct JoltEvaluationProof {\n pub joint_opening_proof: DoryProof,\n}\n\n".to_owned(), + proof_items: "pub type JoltStage2RamAccess = crate::stages::stage2::Stage2RamAccess;\npub type JoltStage2RamOutputLayout = crate::stages::stage2::Stage2RamOutputLayout;\npub type JoltStage2RamData<'a> = crate::stages::stage2::Stage2RamData<'a>;\npub type JoltStageChallengeVector = bolt_verifier_runtime::StageChallengeVector;\npub type JoltStageExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts;\npub type JoltStageOpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue;\n\n#[derive(Clone, Debug)]\npub struct JoltEvaluationProof {\n pub joint_opening_proof: DoryProof,\n}\n\n".to_owned(), inputs_derive: Some("#[derive(Clone, Copy)]".to_owned()), input_fields: " pub evaluation_setup: Option<&'a DoryVerifierSetup>,\n".to_owned(), program_fields: diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs index fcb26cedc1..17a21441d7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs @@ -1071,7 +1071,7 @@ impl Stage1CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::append_labeled_scalar;\n\ + "use bolt_verifier_runtime::append_labeled_scalar;\n\ use jolt_field::Fr;\n\ use jolt_sumcheck::{CompressedLabeledRoundPoly, LabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier};\n\ use jolt_transcript::{Blake2bTranscript, Transcript};" @@ -1080,23 +1080,24 @@ impl Stage1CpuProgram { fn emit_verifier_types() -> &'static str { r"pub type DefaultStage1Transcript = Blake2bTranscript; -pub type Stage1Params = super::common::StageParams; -pub type Stage1NamedEval = super::common::StageNamedEval; -pub type Stage1SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage1ChallengeVector = super::common::StageChallengeVector; -pub type Stage1ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage1Proof = super::common::StageProof; -pub type Stage1VerifierProgramPlan = super::common::VerifierProgramPlanMinimal; - -pub use super::common::{ - ClaimKind as Stage1ClaimKind, RelationKind as Stage1RelationKind, OpeningBatchPlan as Stage1OpeningBatchPlan, +pub type Stage1Params = bolt_verifier_runtime::StageParams; +pub type Stage1NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage1SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage1ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage1ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage1Proof = bolt_verifier_runtime::StageProof; +pub type Stage1VerifierProgramPlan = bolt_verifier_runtime::VerifierProgramPlanMinimal; +pub type Stage1SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage1SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage1SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage1RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage1ClaimKind, OpeningBatchPlan as Stage1OpeningBatchPlan, OpeningClaimPlan as Stage1OpeningClaimPlan, SumcheckBatchPlan as Stage1SumcheckBatchPlan, SumcheckEvalPlan as Stage1SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage1SumcheckInstanceResultPlan, TranscriptSqueezeKind as Stage1TranscriptSqueezeKind, TranscriptSqueezePlan as Stage1TranscriptSqueezePlan, - SumcheckClaimPlan as Stage1SumcheckClaimPlan, - SumcheckDriverPlan as Stage1SumcheckDriverPlan, }; #[derive(Debug)] diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 73e865e936..7bcff9db01 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -926,7 +926,7 @@ impl Stage2CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ + "use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt, RingCore};\n\ use jolt_poly::lagrange::{lagrange_evals, lagrange_kernel_eval};\n\ use jolt_poly::{EqPolynomial, UnivariatePoly};\n\ @@ -937,16 +937,20 @@ impl Stage2CpuProgram { fn emit_verifier_types() -> &'static str { r"pub type DefaultStage2Transcript = Blake2bTranscript; -pub type Stage2NamedEval = super::common::StageNamedEval; -pub type Stage2SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage2ChallengeVector = super::common::StageChallengeVector; -pub type Stage2ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage2Proof = super::common::StageProof; -pub type Stage2OpeningInputValue = super::common::StageOpeningInputValue; -pub type Stage2VerifierProgramPlan = super::common::StageVerifierProgramPlanNoEqualities; - -pub use super::common::{ - ClaimKind as Stage2ClaimKind, RelationKind as Stage2RelationKind, FieldConstantPlan as Stage2FieldConstantPlan, +pub type Stage2NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage2SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage2ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage2ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage2Proof = bolt_verifier_runtime::StageProof; +pub type Stage2OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage2VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlanNoEqualities; +pub type Stage2SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage2SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage2SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage2RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage2ClaimKind, FieldConstantPlan as Stage2FieldConstantPlan, FieldExprKind as Stage2FieldExprKind, FieldExprPlan as Stage2FieldExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, @@ -955,11 +959,8 @@ pub use super::common::{ ProgramStepPlan as Stage2ProgramStepPlan, StageParams as Stage2Params, SumcheckBatchPlan as Stage2SumcheckBatchPlan, SumcheckEvalPlan as Stage2SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage2SumcheckInstanceResultPlan, TranscriptSqueezeKind as Stage2TranscriptSqueezeKind, TranscriptSqueezePlan as Stage2TranscriptSqueezePlan, - SumcheckClaimPlan as Stage2SumcheckClaimPlan, - SumcheckDriverPlan as Stage2SumcheckDriverPlan, }; #[derive(Clone, Copy, Debug)] @@ -986,7 +987,7 @@ pub struct Stage2RamData<'a> { } #[derive(Clone, Debug, Default)] -struct Stage2ValueStore(super::common::ValueStore); +struct Stage2ValueStore(bolt_verifier_runtime::ValueStore); #[derive(Debug)] pub enum VerifyStage2Error { @@ -1002,7 +1003,7 @@ pub enum VerifyStage2Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); " } @@ -1965,7 +1966,7 @@ where proof: proof.proof.clone(), }; store.observe_sumcheck_output(program, &verified)?; - super::common::append_opening_claims( + bolt_verifier_runtime::append_opening_claims( program.opening_inputs, program.opening_claims, program.opening_batches, @@ -1983,7 +1984,7 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, inputs: &[Stage2OpeningInputValue], ) -> Result { - Ok(Self(super::common::ValueStore::with_opening_inputs( + Ok(Self(bolt_verifier_runtime::ValueStore::with_opening_inputs( inputs, program.opening_inputs, )?)) @@ -2089,7 +2090,7 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, ) -> Result<(), VerifyStage2Error> { self.0 - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage2Error::from) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 9a5d42f437..cf3e14a67f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -954,7 +954,7 @@ impl Stage3CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ + "use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ use jolt_field::{Field, Fr};\n\ use jolt_poly::{EqPlusOnePolynomial, EqPolynomial};\n\ use jolt_sumcheck::SumcheckError;\n\ @@ -964,16 +964,20 @@ impl Stage3CpuProgram { fn emit_verifier_types() -> &'static str { r"pub type DefaultStage3Transcript = Blake2bTranscript; -pub type Stage3NamedEval = super::common::StageNamedEval; -pub type Stage3SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage3ChallengeVector = super::common::StageChallengeVector; -pub type Stage3ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage3Proof = super::common::StageProof; -pub type Stage3OpeningInputValue = super::common::StageOpeningInputValue; -pub type Stage3VerifierProgramPlan = super::common::StageVerifierProgramPlan; - -pub use super::common::{ - ClaimKind as Stage3ClaimKind, RelationKind as Stage3RelationKind, FieldConstantPlan as Stage3FieldConstantPlan, +pub type Stage3NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage3SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage3ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage3ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage3Proof = bolt_verifier_runtime::StageProof; +pub type Stage3OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage3VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlan; +pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage3SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage3ClaimKind, FieldConstantPlan as Stage3FieldConstantPlan, FieldExprKind as Stage3FieldExprKind, FieldExprPlan as Stage3FieldExprPlan, OpeningBatchPlan as Stage3OpeningBatchPlan, @@ -984,11 +988,8 @@ pub use super::common::{ ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage3SumcheckInstanceResultPlan, TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, - SumcheckClaimPlan as Stage3SumcheckClaimPlan, - SumcheckDriverPlan as Stage3SumcheckDriverPlan, }; #[derive(Debug)] @@ -1004,7 +1005,7 @@ pub enum VerifyStage3Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); " } @@ -1764,7 +1765,7 @@ where }); } let mut store = - super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; + bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); let mut artifacts = Stage3ExecutionArtifacts::default(); for step in program.steps { @@ -1804,7 +1805,7 @@ pub fn stage3_verifier_program() -> &'static Stage3VerifierProgramPlan { fn verify_stage3_squeeze( program: &'static Stage3VerifierProgramPlan, squeeze: &'static Stage3TranscriptSqueezePlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage3ExecutionArtifacts, ) -> Result<(), VerifyStage3Error> @@ -1820,7 +1821,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage3Error::from)?; artifacts.challenge_vectors.push(Stage3ChallengeVector { symbol: squeeze.symbol, @@ -1833,7 +1834,7 @@ fn verify_stage3_driver( program: &'static Stage3VerifierProgramPlan, driver: &'static Stage3SumcheckDriverPlan, proof: &Stage3Proof, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage3ExecutionArtifacts, ) -> Result<(), VerifyStage3Error> @@ -1866,13 +1867,13 @@ fn verify_batched_stage3( program: &'static Stage3VerifierProgramPlan, driver: &'static Stage3SumcheckDriverPlan, proof: &Stage3SumcheckOutput, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, ) -> Result, VerifyStage3Error> where T: Transcript, { - super::common::verify_batched_sumcheck( + bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, program.claims, @@ -1893,7 +1894,7 @@ where fn observe_stage3_sumcheck_output( program: &'static Stage3VerifierProgramPlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, output: &Stage3SumcheckOutput, ) -> Result<(), VerifyStage3Error> { store.observe_sumcheck_output( @@ -1930,7 +1931,7 @@ fn observe_stage3_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage3Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -1942,7 +1943,7 @@ fn observe_stage3_sumcheck_output( fn expected_batched_output_claim( program: &'static Stage3VerifierProgramPlan, driver: &'static Stage3SumcheckDriverPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage3NamedEval], point: &[Fr], batching_coeffs: &[Fr], @@ -1984,42 +1985,42 @@ fn expected_batched_output_claim( } fn expected_spartan_shift( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage3NamedEval], local_point: &[Fr], ) -> Result { let opening_point = reverse_slice(local_point); let eq_outer = - EqPlusOnePolynomial::::new(super::common::store_point(store, "stage3.input.stage1.NextPC")?.to_vec()) + EqPlusOnePolynomial::::new(bolt_verifier_runtime::store_point(store, "stage3.input.stage1.NextPC")?.to_vec()) .evaluate(&opening_point); let eq_product = EqPlusOnePolynomial::::new( - super::common::store_point(store, "stage3.input.stage2.product_virtual.NextIsNoop")? + bolt_verifier_runtime::store_point(store, "stage3.input.stage2.product_virtual.NextIsNoop")? .to_vec(), ) .evaluate(&opening_point); let weighted_outer = eval_by_name(evals, "stage3.spartan_shift.eval.UnexpandedPC")? - + super::common::store_scalar(store, "stage3.spartan_shift.gamma")? + + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma")? * eval_by_name(evals, "stage3.spartan_shift.eval.PC")? - + super::common::store_scalar(store, "stage3.spartan_shift.gamma2")? + + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma2")? * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagVirtualInstruction")? - + super::common::store_scalar(store, "stage3.spartan_shift.gamma3")? + + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma3")? * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagIsFirstInSequence")?; Ok(eq_outer * weighted_outer - + super::common::store_scalar(store, "stage3.spartan_shift.gamma4")? + + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma4")? * eq_product * (Fr::from_u64(1) - eval_by_name(evals, "stage3.spartan_shift.eval.InstructionFlagIsNoop")?)) } fn expected_instruction_input( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage3NamedEval], local_point: &[Fr], ) -> Result { let opening_point = reverse_slice(local_point); let eq_eval = EqPolynomial::::mle( &opening_point, - super::common::store_point(store, "stage3.input.stage2.product_virtual.LeftInstructionInput")?, + bolt_verifier_runtime::store_point(store, "stage3.input.stage2.product_virtual.LeftInstructionInput")?, ); let left = eval_by_name( evals, @@ -2037,24 +2038,24 @@ fn expected_instruction_input( evals, "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", )? * eval_by_name(evals, "stage3.instruction_input.eval.Imm")?; - Ok(eq_eval * (right + super::common::store_scalar(store, "stage3.instruction_input.gamma")? * left)) + Ok(eq_eval * (right + bolt_verifier_runtime::store_scalar(store, "stage3.instruction_input.gamma")? * left)) } fn expected_registers( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage3NamedEval], local_point: &[Fr], ) -> Result { let opening_point = reverse_slice(local_point); let eq_eval = EqPolynomial::::mle( &opening_point, - super::common::store_point(store, "stage3.input.stage1.RdWriteValue")?, + bolt_verifier_runtime::store_point(store, "stage3.input.stage1.RdWriteValue")?, ); Ok(eq_eval * (eval_by_name(evals, "stage3.registers_claim_reduction.eval.RdWriteValue")? - + super::common::store_scalar(store, "stage3.registers.gamma")? + + bolt_verifier_runtime::store_scalar(store, "stage3.registers.gamma")? * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs1Value")? - + super::common::store_scalar(store, "stage3.registers.gamma2")? + + bolt_verifier_runtime::store_scalar(store, "stage3.registers.gamma2")? * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs2Value")?)) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 6eb35a18dd..3be7cf9aab 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -962,7 +962,7 @@ impl Stage4CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ + "use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ use super::jolt_relations::lt_polynomial_eval;\n\ use jolt_field::{Field, Fr};\n\ use jolt_poly::EqPolynomial;\n\ @@ -1176,15 +1176,20 @@ pub struct Stage4CpuProgramPlan { } fn emit_verifier_type_aliases() -> &'static str { - r#"pub type Stage4NamedEval = super::common::StageNamedEval; -pub type Stage4SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage4ChallengeVector = super::common::StageChallengeVector; -pub type Stage4ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage4Proof = super::common::StageProof; -pub type Stage4OpeningInputValue = super::common::StageOpeningInputValue; - -pub use super::common::{ - ClaimKind as Stage4ClaimKind, RelationKind as Stage4RelationKind, FieldConstantPlan as Stage4FieldConstantPlan, + r#"pub type Stage4NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage4SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage4ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage4ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage4Proof = bolt_verifier_runtime::StageProof; +pub type Stage4OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZeros; +pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage4SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage4ClaimKind, FieldConstantPlan as Stage4FieldConstantPlan, FieldExprKind as Stage4FieldExprKind, FieldExprPlan as Stage4FieldExprPlan, KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan, @@ -1194,11 +1199,8 @@ pub use super::common::{ PointConcatPlan as Stage4PointConcatPlan, PointSlicePlan as Stage4PointSlicePlan, ProgramStepKind as Stage4ProgramStepKind, ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, - StageProgramPlanNoPointZeros as Stage4CpuProgramPlan, SumcheckBatchPlan as Stage4SumcheckBatchPlan, - SumcheckClaimPlan as Stage4SumcheckClaimPlan, SumcheckDriverPlan as Stage4SumcheckDriverPlan, SumcheckEvalPlan as Stage4SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage4SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage4TranscriptSqueezeKind, TranscriptSqueezePlan as Stage4TranscriptSqueezePlan, @@ -1226,7 +1228,7 @@ pub enum VerifyStage4Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); "#, ); source @@ -1956,7 +1958,7 @@ where }); } let mut store = - super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; + bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); let mut artifacts = Stage4ExecutionArtifacts::default(); for step in program.steps { @@ -1998,7 +2000,7 @@ pub fn stage4_verifier_program() -> &'static Stage4VerifierProgramPlan { fn verify_stage4_squeeze( program: &'static Stage4VerifierProgramPlan, squeeze: &'static Stage4TranscriptSqueezePlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage4ExecutionArtifacts, ) -> Result<(), VerifyStage4Error> @@ -2014,7 +2016,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage4Error::from)?; artifacts.challenge_vectors.push(Stage4ChallengeVector { symbol: squeeze.symbol, @@ -2038,7 +2040,7 @@ fn verify_stage4_driver( program: &'static Stage4VerifierProgramPlan, driver: &'static Stage4SumcheckDriverPlan, proof: &Stage4Proof, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage4ExecutionArtifacts, ) -> Result<(), VerifyStage4Error> @@ -2071,13 +2073,13 @@ fn verify_batched_stage4( program: &'static Stage4VerifierProgramPlan, driver: &'static Stage4SumcheckDriverPlan, proof: &Stage4SumcheckOutput, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, ) -> Result, VerifyStage4Error> where T: Transcript, { - super::common::verify_batched_sumcheck( + bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, program.claims, @@ -2098,7 +2100,7 @@ where fn observe_stage4_sumcheck_output( program: &'static Stage4VerifierProgramPlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, output: &Stage4SumcheckOutput, ) -> Result<(), VerifyStage4Error> { store.observe_sumcheck_output( @@ -2138,7 +2140,7 @@ fn observe_stage4_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage4Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2150,7 +2152,7 @@ fn observe_stage4_sumcheck_output( fn expected_batched_output_claim( program: &'static Stage4VerifierProgramPlan, driver: &'static Stage4SumcheckDriverPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage4NamedEval], point: &[Fr], batching_coeffs: &[Fr], @@ -2195,11 +2197,11 @@ fn expected_batched_output_claim( } fn expected_registers_read_write( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage4NamedEval], local_point: &[Fr], ) -> Result { - let trace_point = super::common::store_point(store, "stage4.input.stage3.registers.RdWriteValue")?; + let trace_point = bolt_verifier_runtime::store_point(store, "stage4.input.stage3.registers.RdWriteValue")?; let r_cycle = normalize_stage4_registers_rw_cycle_point( local_point, trace_point.len(), @@ -2214,18 +2216,18 @@ fn expected_registers_read_write( let rs2_ra = eval_by_name(evals, "stage4.registers_read_write.eval.Rs2Ra")?; let rd_wa = eval_by_name(evals, "stage4.registers_read_write.eval.RdWa")?; let rd_inc = eval_by_name(evals, "stage4.registers_read_write.eval.RdInc")?; - let gamma = super::common::store_scalar(store, "stage4.registers_read_write.gamma")?; + let gamma = bolt_verifier_runtime::store_scalar(store, "stage4.registers_read_write.gamma")?; Ok(eq_eval * (rd_wa * (registers_val + rd_inc) + gamma * (rs1_ra * registers_val + gamma * rs2_ra * registers_val))) } fn expected_ram_val_check( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage4NamedEval], local_point: &[Fr], ) -> Result { - let ram_val_point = super::common::store_point(store, "stage4.input.stage2.RamVal")?; + let ram_val_point = bolt_verifier_runtime::store_point(store, "stage4.input.stage2.RamVal")?; let r_cycle_prime = reverse_slice(local_point); let r_cycle = suffix_point( ram_val_point, @@ -2233,7 +2235,7 @@ fn expected_ram_val_check( "stage4.input.stage2.RamVal", )?; let lt_eval = lt_polynomial_eval(&r_cycle_prime, r_cycle); - let gamma = super::common::store_scalar(store, "stage4.ram_val_check.gamma")?; + let gamma = bolt_verifier_runtime::store_scalar(store, "stage4.ram_val_check.gamma")?; let ram_ra = eval_by_name(evals, "stage4.ram_val_check.eval.RamRa")?; let ram_inc = eval_by_name(evals, "stage4.ram_val_check.eval.RamInc")?; Ok(ram_inc * ram_ra * (lt_eval + gamma)) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index fd0662502f..039b22c5bb 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -963,7 +963,7 @@ impl Stage5CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice, suffix_point};\n\ + "use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice, suffix_point};\n\ use super::jolt_relations::{identity_polynomial_eval, lt_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval};\n\ use jolt_field::{Field, Fr, RingCore};\n\ use jolt_lookup_tables::LookupTableKind;\n\ @@ -1178,15 +1178,20 @@ pub struct Stage5CpuProgramPlan { } fn emit_verifier_type_aliases() -> &'static str { - r#"pub type Stage5NamedEval = super::common::StageNamedEval; -pub type Stage5SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage5ChallengeVector = super::common::StageChallengeVector; -pub type Stage5ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage5Proof = super::common::StageProof; -pub type Stage5OpeningInputValue = super::common::StageOpeningInputValue; - -pub use super::common::{ - ClaimKind as Stage5ClaimKind, RelationKind as Stage5RelationKind, FieldConstantPlan as Stage5FieldConstantPlan, + r#"pub type Stage5NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage5SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage5ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage5ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage5Proof = bolt_verifier_runtime::StageProof; +pub type Stage5OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZeros; +pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage5SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage5RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage5ClaimKind, FieldConstantPlan as Stage5FieldConstantPlan, FieldExprKind as Stage5FieldExprKind, FieldExprPlan as Stage5FieldExprPlan, KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan, @@ -1196,11 +1201,8 @@ pub use super::common::{ PointConcatPlan as Stage5PointConcatPlan, PointSlicePlan as Stage5PointSlicePlan, ProgramStepKind as Stage5ProgramStepKind, ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params, - StageProgramPlanNoPointZeros as Stage5CpuProgramPlan, SumcheckBatchPlan as Stage5SumcheckBatchPlan, - SumcheckClaimPlan as Stage5SumcheckClaimPlan, SumcheckDriverPlan as Stage5SumcheckDriverPlan, SumcheckEvalPlan as Stage5SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage5SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage5TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage5TranscriptSqueezeKind, TranscriptSqueezePlan as Stage5TranscriptSqueezePlan, @@ -1228,7 +1230,7 @@ pub enum VerifyStage5Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); "#, ); source @@ -1958,7 +1960,7 @@ where }); } let mut store = - super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; + bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); let mut artifacts = Stage5ExecutionArtifacts::default(); for step in program.steps { @@ -2000,7 +2002,7 @@ pub fn stage5_verifier_program() -> &'static Stage5VerifierProgramPlan { fn verify_stage5_squeeze( program: &'static Stage5VerifierProgramPlan, squeeze: &'static Stage5TranscriptSqueezePlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage5ExecutionArtifacts, ) -> Result<(), VerifyStage5Error> @@ -2016,7 +2018,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage5Error::from)?; artifacts.challenge_vectors.push(Stage5ChallengeVector { symbol: squeeze.symbol, @@ -2040,7 +2042,7 @@ fn verify_stage5_driver( program: &'static Stage5VerifierProgramPlan, driver: &'static Stage5SumcheckDriverPlan, proof: &Stage5Proof, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage5ExecutionArtifacts, ) -> Result<(), VerifyStage5Error> @@ -2073,13 +2075,13 @@ fn verify_batched_stage5( program: &'static Stage5VerifierProgramPlan, driver: &'static Stage5SumcheckDriverPlan, proof: &Stage5SumcheckOutput, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, ) -> Result, VerifyStage5Error> where T: Transcript, { - super::common::verify_batched_sumcheck( + bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, program.claims, @@ -2100,7 +2102,7 @@ where fn observe_stage5_sumcheck_output( program: &'static Stage5VerifierProgramPlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, output: &Stage5SumcheckOutput, ) -> Result<(), VerifyStage5Error> { store.observe_sumcheck_output( @@ -2140,7 +2142,7 @@ fn observe_stage5_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage5Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2152,7 +2154,7 @@ fn observe_stage5_sumcheck_output( fn expected_batched_output_claim( program: &'static Stage5VerifierProgramPlan, driver: &'static Stage5SumcheckDriverPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage5NamedEval], point: &[Fr], batching_coeffs: &[Fr], @@ -2200,7 +2202,7 @@ fn expected_batched_output_claim( } fn expected_instruction_read_raf( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage5NamedEval], local_point: &[Fr], ) -> Result { @@ -2217,7 +2219,7 @@ fn expected_instruction_read_raf( let (r_address_prime, r_cycle) = local_point.split_at(LOG_K); let r_cycle_prime = reverse_slice(r_cycle); - let r_reduction = super::common::store_point(store, "stage5.input.stage2.instruction.LookupOutput")?; + let r_reduction = bolt_verifier_runtime::store_point(store, "stage5.input.stage2.instruction.LookupOutput")?; let eq_eval_r_reduction = EqPolynomial::::mle(r_reduction, &r_cycle_prime); let left_operand_eval = operand_polynomial_eval(r_address_prime, true); @@ -2249,7 +2251,7 @@ fn expected_instruction_read_raf( evals, "stage5.instruction_read_raf.eval.InstructionRafFlag", )?; - let gamma = super::common::store_scalar(store, "stage5.instruction_read_raf.gamma")?; + let gamma = bolt_verifier_runtime::store_scalar(store, "stage5.instruction_read_raf.gamma")?; let raf_claim = (Fr::from_u64(1) - raf_flag_claim) * (left_operand_eval + gamma * right_operand_eval) @@ -2258,27 +2260,27 @@ fn expected_instruction_read_raf( } fn expected_ram_ra_claim_reduction( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage5NamedEval], local_point: &[Fr], ) -> Result { let r_cycle_reduced = reverse_slice(local_point); let r_cycle_raf = suffix_point( - super::common::store_point(store, "stage5.input.stage2.ram_raf.RamRa")?, + bolt_verifier_runtime::store_point(store, "stage5.input.stage2.ram_raf.RamRa")?, r_cycle_reduced.len(), "stage5.input.stage2.ram_raf.RamRa", )?; let r_cycle_rw = suffix_point( - super::common::store_point(store, "stage5.input.stage2.ram_read_write.RamRa")?, + bolt_verifier_runtime::store_point(store, "stage5.input.stage2.ram_read_write.RamRa")?, r_cycle_reduced.len(), "stage5.input.stage2.ram_read_write.RamRa", )?; let r_cycle_val = suffix_point( - super::common::store_point(store, "stage5.input.stage4.ram_val_check.RamRa")?, + bolt_verifier_runtime::store_point(store, "stage5.input.stage4.ram_val_check.RamRa")?, r_cycle_reduced.len(), "stage5.input.stage4.ram_val_check.RamRa", )?; - let gamma = super::common::store_scalar(store, "stage5.ram_ra_claim_reduction.gamma")?; + let gamma = bolt_verifier_runtime::store_scalar(store, "stage5.ram_ra_claim_reduction.gamma")?; let eq_combined = EqPolynomial::::mle(r_cycle_raf, &r_cycle_reduced) + gamma * EqPolynomial::::mle(r_cycle_rw, &r_cycle_reduced) + gamma.square() * EqPolynomial::::mle(r_cycle_val, &r_cycle_reduced); @@ -2287,11 +2289,11 @@ fn expected_ram_ra_claim_reduction( } fn expected_registers_val_evaluation( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage5NamedEval], local_point: &[Fr], ) -> Result { - let registers_val_point = super::common::store_point(store, "stage5.input.stage4.registers.RegistersVal")?; + let registers_val_point = bolt_verifier_runtime::store_point(store, "stage5.input.stage4.registers.RegistersVal")?; let r_cycle = suffix_point( registers_val_point, local_point.len(), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index a913e7eaf7..c4920422ca 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -987,7 +987,7 @@ impl Stage6CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{batch_claims, find_batch, find_plan};\n\ + "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ use super::jolt_relations::{expected_stage67_booleanity, expected_stage67_bytecode_read_raf, expected_stage67_hamming_booleanity, expected_stage67_inc_claim_reduction, expected_stage67_instruction_ra_virtual, expected_stage67_ram_ra_virtual, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ @@ -1208,15 +1208,20 @@ pub struct Stage6CpuProgramPlan { } fn emit_verifier_type_aliases() -> &'static str { - r#"pub type Stage6NamedEval = super::common::StageNamedEval; -pub type Stage6SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage6ChallengeVector = super::common::StageChallengeVector; -pub type Stage6ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage6Proof = super::common::StageProof; -pub type Stage6OpeningInputValue = super::common::StageOpeningInputValue; - -pub use super::common::{ - ClaimKind as Stage6ClaimKind, RelationKind as Stage6RelationKind, FieldConstantPlan as Stage6FieldConstantPlan, + r#"pub type Stage6NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage6SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage6ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage6ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage6Proof = bolt_verifier_runtime::StageProof; +pub type Stage6OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage6CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; +pub type Stage6SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage6SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage6SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage6RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage6ClaimKind, FieldConstantPlan as Stage6FieldConstantPlan, FieldExprKind as Stage6FieldExprKind, FieldExprPlan as Stage6FieldExprPlan, KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan, @@ -1226,11 +1231,9 @@ pub use super::common::{ PointConcatPlan as Stage6PointConcatPlan, PointSlicePlan as Stage6PointSlicePlan, PointZeroPlan as Stage6PointZeroPlan, ProgramStepKind as Stage6ProgramStepKind, ProgramStepPlan as Stage6ProgramStepPlan, - StageParams as Stage6Params, StageProgramPlan as Stage6CpuProgramPlan, + StageParams as Stage6Params, SumcheckBatchPlan as Stage6SumcheckBatchPlan, - SumcheckClaimPlan as Stage6SumcheckClaimPlan, SumcheckDriverPlan as Stage6SumcheckDriverPlan, SumcheckEvalPlan as Stage6SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage6SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage6TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage6TranscriptSqueezeKind, TranscriptSqueezePlan as Stage6TranscriptSqueezePlan, @@ -1360,7 +1363,7 @@ pub enum VerifyStage6Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); "#, ); source @@ -2130,7 +2133,7 @@ where }); } let mut store = - super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; + bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); store.seed_point_zeros(program.point_zeros); let mut artifacts = Stage6ExecutionArtifacts::default(); @@ -2181,7 +2184,7 @@ pub fn stage6_verifier_program() -> &'static Stage6VerifierProgramPlan { fn verify_stage6_squeeze( program: &'static Stage6VerifierProgramPlan, squeeze: &'static Stage6TranscriptSqueezePlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage6ExecutionArtifacts, ) -> Result<(), VerifyStage6Error> @@ -2201,7 +2204,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage6Error::from)?; artifacts.challenge_vectors.push(Stage6ChallengeVector { symbol: squeeze.symbol, @@ -2226,7 +2229,7 @@ fn verify_stage6_driver( driver: &'static Stage6SumcheckDriverPlan, proof: &Stage6Proof, verifier_data: Option<&Stage6VerifierData>, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage6ExecutionArtifacts, ) -> Result<(), VerifyStage6Error> @@ -2260,13 +2263,13 @@ fn verify_batched_stage6( driver: &'static Stage6SumcheckDriverPlan, proof: &Stage6SumcheckOutput, verifier_data: Option<&Stage6VerifierData>, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, ) -> Result, VerifyStage6Error> where T: Transcript, { - super::common::verify_batched_sumcheck( + bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, program.claims, @@ -2295,7 +2298,7 @@ where fn observe_stage6_sumcheck_output( program: &'static Stage6VerifierProgramPlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, output: &Stage6SumcheckOutput, ) -> Result<(), VerifyStage6Error> { store.observe_sumcheck_output( @@ -2335,7 +2338,7 @@ fn observe_stage6_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage6Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2348,7 +2351,7 @@ fn expected_batched_output_claim( program: &'static Stage6VerifierProgramPlan, driver: &'static Stage6SumcheckDriverPlan, verifier_data: Option<&Stage6VerifierData>, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], point: &[Fr], batching_coeffs: &[Fr], @@ -2412,7 +2415,7 @@ fn expected_batched_output_claim( fn expected_bytecode_read_raf( program: &'static Stage6VerifierProgramPlan, data: &Stage6BytecodeReadRafData, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { @@ -2431,7 +2434,7 @@ fn expected_bytecode_read_raf( fn expected_booleanity( program: &'static Stage6VerifierProgramPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { @@ -2440,7 +2443,7 @@ fn expected_booleanity( } fn expected_hamming_booleanity( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { @@ -2448,7 +2451,7 @@ fn expected_hamming_booleanity( } fn expected_ram_ra_virtual( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { @@ -2457,7 +2460,7 @@ fn expected_ram_ra_virtual( fn expected_instruction_ra_virtual( program: &'static Stage6VerifierProgramPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { @@ -2465,7 +2468,7 @@ fn expected_instruction_ra_virtual( } fn expected_inc_claim_reduction( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 823145d5d3..d8030e1238 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -984,7 +984,7 @@ impl Stage7CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ + "use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ use jolt_field::{Field, Fr, RingCore};\n\ use jolt_poly::EqPolynomial;\n\ use jolt_sumcheck::SumcheckError;\n\ @@ -1205,15 +1205,20 @@ pub struct Stage7CpuProgramPlan { } fn emit_verifier_type_aliases() -> &'static str { - r#"pub type Stage7NamedEval = super::common::StageNamedEval; -pub type Stage7SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage7ChallengeVector = super::common::StageChallengeVector; -pub type Stage7ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage7Proof = super::common::StageProof; -pub type Stage7OpeningInputValue = super::common::StageOpeningInputValue; - -pub use super::common::{ - ClaimKind as Stage7ClaimKind, RelationKind as Stage7RelationKind, FieldConstantPlan as Stage7FieldConstantPlan, + r#"pub type Stage7NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage7SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage7ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage7ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage7Proof = bolt_verifier_runtime::StageProof; +pub type Stage7OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage7CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; +pub type Stage7SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage7SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage7SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage7RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage7ClaimKind, FieldConstantPlan as Stage7FieldConstantPlan, FieldExprKind as Stage7FieldExprKind, FieldExprPlan as Stage7FieldExprPlan, KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan, @@ -1223,11 +1228,9 @@ pub use super::common::{ PointConcatPlan as Stage7PointConcatPlan, PointSlicePlan as Stage7PointSlicePlan, PointZeroPlan as Stage7PointZeroPlan, ProgramStepKind as Stage7ProgramStepKind, ProgramStepPlan as Stage7ProgramStepPlan, - StageParams as Stage7Params, StageProgramPlan as Stage7CpuProgramPlan, + StageParams as Stage7Params, SumcheckBatchPlan as Stage7SumcheckBatchPlan, - SumcheckClaimPlan as Stage7SumcheckClaimPlan, SumcheckDriverPlan as Stage7SumcheckDriverPlan, SumcheckEvalPlan as Stage7SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage7SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage7TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage7TranscriptSqueezeKind, TranscriptSqueezePlan as Stage7TranscriptSqueezePlan, @@ -1255,7 +1258,7 @@ pub enum VerifyStage7Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); "#, ); source @@ -2023,7 +2026,7 @@ where }); } let mut store = - super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; + bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); store.seed_point_zeros(program.point_zeros); let mut artifacts = Stage7ExecutionArtifacts::default(); @@ -2073,7 +2076,7 @@ pub fn stage7_verifier_program() -> &'static Stage7VerifierProgramPlan { fn verify_stage7_squeeze( program: &'static Stage7VerifierProgramPlan, squeeze: &'static Stage7TranscriptSqueezePlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage7ExecutionArtifacts, ) -> Result<(), VerifyStage7Error> @@ -2089,7 +2092,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage7Error::from)?; artifacts.challenge_vectors.push(Stage7ChallengeVector { symbol: squeeze.symbol, @@ -2113,7 +2116,7 @@ fn verify_stage7_driver( program: &'static Stage7VerifierProgramPlan, driver: &'static Stage7SumcheckDriverPlan, proof: &Stage7Proof, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage7ExecutionArtifacts, ) -> Result<(), VerifyStage7Error> @@ -2146,13 +2149,13 @@ fn verify_batched_stage7( program: &'static Stage7VerifierProgramPlan, driver: &'static Stage7SumcheckDriverPlan, proof: &Stage7SumcheckOutput, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, ) -> Result, VerifyStage7Error> where T: Transcript, { - super::common::verify_batched_sumcheck( + bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, program.claims, @@ -2173,7 +2176,7 @@ where fn observe_stage7_sumcheck_output( program: &'static Stage7VerifierProgramPlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, output: &Stage7SumcheckOutput, ) -> Result<(), VerifyStage7Error> { store.observe_sumcheck_output( @@ -2211,7 +2214,7 @@ fn observe_stage7_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage7Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2223,7 +2226,7 @@ fn observe_stage7_sumcheck_output( fn expected_batched_output_claim( program: &'static Stage7VerifierProgramPlan, driver: &'static Stage7SumcheckDriverPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage7NamedEval], point: &[Fr], batching_coeffs: &[Fr], @@ -2267,12 +2270,12 @@ fn expected_batched_output_claim( fn expected_hamming_weight_claim_reduction( program: &'static Stage7VerifierProgramPlan, driver: &'static Stage7SumcheckDriverPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage7NamedEval], local_point: &[Fr], ) -> Result { let rho_rev = reverse_slice(local_point); - let booleanity_point = super::common::store_point(store, "stage7.input.stage6.booleanity.InstructionRa_0")?; + let booleanity_point = bolt_verifier_runtime::store_point(store, "stage7.input.stage6.booleanity.InstructionRa_0")?; let r_addr_bool = booleanity_point .get(..local_point.len()) @@ -2282,7 +2285,7 @@ fn expected_hamming_weight_claim_reduction( actual: booleanity_point.len(), })?; let eq_bool = EqPolynomial::::mle(&rho_rev, r_addr_bool); - let gamma = super::common::store_scalar(store, "stage7.hamming_weight_claim_reduction.gamma")?; + let gamma = bolt_verifier_runtime::store_scalar(store, "stage7.hamming_weight_claim_reduction.gamma")?; let mut gamma_power = Fr::from_u64(1); let mut expected = Fr::from_u64(0); let mut eval_plans = program @@ -2306,7 +2309,7 @@ fn expected_hamming_weight_claim_reduction( } fn stage7_virtualization_point<'a>( - store: &'a super::common::ValueStore, + store: &'a bolt_verifier_runtime::ValueStore, oracle: &str, log_k_chunk: usize, ) -> Result<&'a [Fr], VerifyStage7Error> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs index adef9f0d31..ba761a3030 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage8.rs @@ -293,7 +293,10 @@ impl Stage8CpuProgram { source.push_str("#![allow(clippy::too_many_lines)]\n\n"); match self.role { Role::Verifier => source.push_str( - "pub use super::common::{ClaimKind as Stage8ClaimKind, PcsProofMode as Stage8PcsProofMode, SourceStage as Stage8SourceStage, StageParams as Stage8Params, TypedPlanSymbol};\n\n\ + "pub use bolt_verifier_runtime::{ClaimKind as Stage8ClaimKind, PcsProofMode as Stage8PcsProofMode, StageParams as Stage8Params, TypedPlanSymbol};\n\n\ + #[derive(Clone, Copy, Debug, PartialEq, Eq)]\n\ + pub enum Stage8SourceStage {\n Stage6,\n Stage7,\n}\n\n\ + impl Stage8SourceStage {\n pub fn as_str(self) -> &'static str {\n match self {\n Self::Stage6 => \"stage6\",\n Self::Stage7 => \"stage7\",\n }\n }\n}\n\n\ #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]\n\ pub enum Stage8OpeningInputTag {}\n\ pub type Stage8OpeningInputSymbol = TypedPlanSymbol;\n\ diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index f812297135..89a427cc27 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -23,19 +23,23 @@ //! Treat changes here as Jolt protocol changes, not as compiler-output //! cleanups. Generic Bolt verifier scaffolding (typed plan structs, //! `ValueStore`, generic sumcheck verification, generic field-expr -//! dispatch) lives in `super::common` instead. +//! dispatch) lives in `bolt_verifier_runtime` instead. //! //! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition. use jolt_field::{Field, Fr, MulPow2, RingCore}; use jolt_poly::EqPolynomial; -use super::common::{ +use bolt_verifier_runtime::{ eval_by_name, field_powers, indexed_boolean_eq, indexed_evals_by_prefix_any, prefix_point, - reverse_slice, store_point, store_scalar, suffix_point, OpeningInputPlan, RelationKind, - RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, + reverse_slice, store_point, store_scalar, suffix_point, OpeningInputPlan, RuntimePlanError, + StageNamedEval, SumcheckInstanceResultPlan, ValueStore, }; +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[rustfmt::skip] +pub enum JoltRelationKind { Stage1OuterUniskip, Stage1OuterRemaining, Stage2ProductVirtualUniskip, Stage2RamReadWrite, Stage2ProductVirtualRemainder, Stage2InstructionLookupClaimReduction, Stage2RamRafEvaluation, Stage2RamOutputCheck, Stage2Batched, Stage3SpartanShift, Stage3InstructionInput, Stage3RegistersClaimReduction, Stage3Batched, Stage4RegistersReadWrite, Stage4RamValCheck, Stage4Batched, Stage5InstructionReadRaf, Stage5RamRaClaimReduction, Stage5RegistersValEvaluation, Stage5Batched, Stage6BytecodeReadRaf, Stage6Booleanity, Stage6HammingBooleanity, Stage6RamRaVirtual, Stage6InstructionRaVirtual, Stage6IncClaimReduction, Stage6Batched, Stage7HammingWeightClaimReduction, Stage7Batched } + pub fn bytecode_gamma_powers(gamma: Fr) -> [Fr; 8] { let mut powers = [Fr::from_u64(1); 8]; for index in 1..powers.len() { @@ -142,12 +146,12 @@ pub trait Stage67BytecodeEntry { } pub fn stage67_trace_rounds( - instance_results: &[SumcheckInstanceResultPlan], + instance_results: &[SumcheckInstanceResultPlan], symbols: &Stage67RelationSymbols, ) -> Result { instance_results .iter() - .find(|instance| instance.relation == RelationKind::Stage6HammingBooleanity) + .find(|instance| instance.relation == JoltRelationKind::Stage6HammingBooleanity) .map(|instance| instance.num_rounds) .ok_or(RuntimePlanError::MissingValue { symbol: symbols.hamming_booleanity_instance, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 523ee60317..b4285ecf8a 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1229,7 +1229,7 @@ fn stage3_rust_targets_extract_and_compile() { assert!(verifier_source.source.contains("pub fn verify_stage3")); assert!(verifier_source .source - .contains("super::common::verify_batched_sumcheck")); + .contains("bolt_verifier_runtime::verify_batched_sumcheck")); assert!(verifier_source .source .contains("Stage3OpeningClaimEqualityPlan")); @@ -1314,7 +1314,7 @@ fn stage4_rust_targets_extract_and_compile() { assert!(verifier_source.source.contains("LabelWithCount")); assert!(verifier_source .source - .contains("super::common::verify_batched_sumcheck")); + .contains("bolt_verifier_runtime::verify_batched_sumcheck")); assert!(verifier_source.source.contains("stage4_verifier_program")); assert_or_update_fixture("tests/fixtures/prove_stage4.rs", &prover_source.source); assert_or_update_fixture("tests/fixtures/verify_stage4.rs", &verifier_source.source); @@ -1433,7 +1433,7 @@ fn stage5_rust_targets_extract_and_compile() { assert!(!verifier_source.source.contains("jolt.stage5.ram_val_check")); assert!(verifier_source .source - .contains("super::common::verify_batched_sumcheck")); + .contains("bolt_verifier_runtime::verify_batched_sumcheck")); assert!(verifier_source.source.contains("stage5_verifier_program")); assert_rust_source_compiles(&prover_source.filename, &prover_source.source); assert_rust_source_compiles(&verifier_source.filename, &verifier_source.source); @@ -1578,7 +1578,7 @@ fn stage6_rust_targets_extract_and_compile() { .contains("stage6.inc_claim_reduction.eval.RdInc")); assert!(verifier_source .source - .contains("super::common::verify_batched_sumcheck")); + .contains("bolt_verifier_runtime::verify_batched_sumcheck")); assert!(verifier_source.source.contains("stage6_verifier_program")); assert_rust_source_compiles(&prover_source.filename, &prover_source.source); assert_rust_source_compiles(&verifier_source.filename, &verifier_source.source); @@ -1665,7 +1665,7 @@ fn stage7_rust_targets_extract_and_compile() { .contains("stage7.hamming_weight_claim_reduction.eval.InstructionRa_0")); assert!(verifier_source .source - .contains("super::common::verify_batched_sumcheck")); + .contains("bolt_verifier_runtime::verify_batched_sumcheck")); assert!(verifier_source.source.contains("stage7_verifier_program")); assert_rust_source_compiles(&prover_source.filename, &prover_source.source); assert_rust_source_compiles(&verifier_source.filename, &verifier_source.source); @@ -3172,16 +3172,9 @@ fn assert_rust_source_compiles(_filename: &str, source: &str) { ) .expect("write generated cargo manifest"); std::fs::create_dir_all(dir.join("src")).expect("create generated src dir"); - if source.contains("super::common") || source.contains("super::jolt_relations") { - // Tier A: generic Bolt verifier scaffolding. - std::fs::write( - dir.join("src/common.rs"), - generated_verifier_common_source(&workspace_root), - ) - .expect("write generated common source"); - // Tier B: audited Jolt verifier core. Always staged alongside - // common.rs because jolt_relations.rs depends on common.rs items. - // See crates/bolt/GOAL.md "Audit Tiers". + if source.contains("super::jolt_relations") { + // Tier B: audited Jolt verifier core. Tier A is provided by the + // bolt-verifier-runtime crate and is not staged as generated source. std::fs::write( dir.join("src/jolt_relations.rs"), generated_verifier_jolt_relations_source(&workspace_root), @@ -3190,7 +3183,7 @@ fn assert_rust_source_compiles(_filename: &str, source: &str) { std::fs::write(dir.join("src/generated.rs"), source).expect("write generated source"); std::fs::write( dir.join("src/lib.rs"), - "pub mod common;\npub mod jolt_relations;\n#[rustfmt::skip]\npub mod generated;\n", + "pub mod jolt_relations;\n#[rustfmt::skip]\npub mod generated;\n", ) .expect("write generated lib wrapper"); } else { @@ -3378,11 +3371,9 @@ fn assert_generated_stage1_self_parity_runs( .expect("write generated cargo manifest"); let src_dir = dir.join("src"); std::fs::create_dir_all(&src_dir).expect("create generated src dir"); - let main_source = if verifier_source.source.contains("super::common") - || verifier_source.source.contains("super::jolt_relations") - { - write_verifier_common_module(&src_dir, &workspace_root); - format!("mod common;\nmod jolt_relations;\n{main_source}") + let main_source = if verifier_source.source.contains("super::jolt_relations") { + write_verifier_jolt_relations_module(&src_dir, &workspace_root); + format!("mod jolt_relations;\n{main_source}") } else { main_source.to_owned() }; @@ -3428,11 +3419,12 @@ fn assert_generated_jolt_chain_self_parity_runs(files: &[&RustSourceFile], main_ .expect("write generated cargo manifest"); let src_dir = dir.join("src"); std::fs::create_dir_all(&src_dir).expect("create generated src dir"); - let main_source = if files.iter().any(|file| { - file.source.contains("super::common") || file.source.contains("super::jolt_relations") - }) { - write_verifier_common_module(&src_dir, &workspace_root); - format!("mod common;\nmod jolt_relations;\n{main_source}") + let main_source = if files + .iter() + .any(|file| file.source.contains("super::jolt_relations")) + { + write_verifier_jolt_relations_module(&src_dir, &workspace_root); + format!("mod jolt_relations;\n{main_source}") } else { main_source.to_owned() }; @@ -3462,12 +3454,7 @@ fn assert_generated_jolt_chain_self_parity_runs(files: &[&RustSourceFile], main_ let _ = std::fs::remove_dir_all(dir); } -fn write_verifier_common_module(src_dir: &Path, workspace_root: &Path) { - std::fs::write( - src_dir.join("common.rs"), - generated_verifier_common_source(workspace_root), - ) - .expect("write generated common source"); +fn write_verifier_jolt_relations_module(src_dir: &Path, workspace_root: &Path) { std::fs::write( src_dir.join("jolt_relations.rs"), generated_verifier_jolt_relations_source(workspace_root), @@ -3475,15 +3462,6 @@ fn write_verifier_common_module(src_dir: &Path, workspace_root: &Path) { .expect("write generated jolt_relations source"); } -fn generated_verifier_common_source(workspace_root: &Path) -> String { - let common = - std::fs::read_to_string(workspace_root.join("crates/jolt-verifier/src/stages/common.rs")) - .expect("read generated verifier common stage source"); - format!( - "#![allow(dead_code, unused_imports, unused_macros, reason = \"generated verifier helpers are shared across generated stage subsets\")]\n{common}" - ) -} - fn generated_verifier_jolt_relations_source(workspace_root: &Path) -> String { let jolt_relations = std::fs::read_to_string( workspace_root.join("crates/jolt-verifier/src/stages/jolt_relations.rs"), @@ -3508,7 +3486,10 @@ fn generated_jolt_runtime_available() -> bool { .join("crates/jolt-kernels/Cargo.toml") .exists() && workspace_root - .join("crates/jolt-verifier/src/stages/common.rs") + .join("crates/bolt-verifier-runtime/Cargo.toml") + .exists() + && workspace_root + .join("crates/jolt-verifier/src/stages/jolt_relations.rs") .exists() } @@ -3537,6 +3518,7 @@ ark-ff = {{ git = "https://github.com/a16z/arkworks-algebra", branch = "dev/twis ark-serialize = {{ git = "https://github.com/a16z/arkworks-algebra", branch = "dev/twist-shout" }} [dependencies] +bolt-verifier-runtime = {{ path = "{}" }} jolt-dory = {{ path = "{}" }} jolt-field = {{ path = "{}" }} jolt-kernels = {{ path = "{}" }} @@ -3551,6 +3533,9 @@ rayon = "1.12.0" serde = {{ version = "1.0", default-features = false, features = ["derive"] }} tracing = {{ version = "0.1.37", default-features = false, features = ["attributes"] }} "#, + workspace_root + .join("crates/bolt-verifier-runtime") + .display(), workspace_root.join("crates/jolt-dory").display(), workspace_root.join("crates/jolt-field").display(), workspace_root.join("crates/jolt-kernels").display(), diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 252681c08e..6144530a73 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -16,11 +16,10 @@ const GENERATED_VERIFIER_BASELINE_LOC_CEILING: usize = 9_185; const VERIFIER_RS_BASELINE_LOC_CEILING: usize = VERIFIER_RS_TARGET_LOC; const STAGE6_STAGE7_BASELINE_LOC_CEILING: usize = STAGE6_STAGE7_TARGET_LOC; -/// Tier A ceiling: generic Bolt verifier scaffolding lives in -/// `stages/common.rs`. The long-term direction is to shrink Tier A by moving -/// helpers into typed plan data driven from MLIR, so this ceiling should -/// only ever ratchet down. -const BOLT_RUNTIME_BASELINE_LOC_CEILING: usize = 1_400; +/// Tier A ceiling inside the generated verifier crate. S2 moves generic Bolt +/// verifier scaffolding into `crates/bolt-verifier-runtime`, so this generated +/// surface should stay at zero after the extraction. +const BOLT_RUNTIME_BASELINE_LOC_CEILING: usize = 0; /// Tier B ceiling: hand-written Jolt verifier math lives in /// `stages/jolt_relations.rs`. Growth here is a *protocol-math* decision and @@ -123,8 +122,8 @@ const GENERIC_COMPILER_JOLT_PATTERNS: &[&str] = &[ struct VerifierCleanupMetrics { total_loc: usize, generated_surface_loc: usize, - /// Tier A: generic Bolt verifier scaffolding - /// (`crates/jolt-verifier/src/stages/common.rs`). + /// Tier A: generic Bolt verifier scaffolding still emitted inside + /// `crates/jolt-verifier/src` after extraction. bolt_runtime_loc: usize, /// Tier B: audited Jolt verifier core /// (`crates/jolt-verifier/src/stages/jolt_relations.rs`). @@ -212,10 +211,10 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { metrics.generated_surface_loc, GENERATED_VERIFIER_STRETCH_LOC, ); } - assert!( - metrics.bolt_runtime_loc <= BOLT_RUNTIME_BASELINE_LOC_CEILING, - "Tier A bolt verifier runtime grew to {} LOC (ceiling {}); generic Bolt scaffolding should ratchet down, not up", + assert_eq!( metrics.bolt_runtime_loc, BOLT_RUNTIME_BASELINE_LOC_CEILING, + "Tier A bolt verifier runtime grew to {} LOC (ceiling {}); generic Bolt scaffolding should ratchet down, not up", + metrics.bolt_runtime_loc, BOLT_RUNTIME_BASELINE_LOC_CEILING ); assert!( metrics.jolt_verifier_core_loc <= JOLT_VERIFIER_CORE_BASELINE_LOC_CEILING, @@ -536,6 +535,9 @@ fn count_stage_local_generic_plan_structs(source: &str) -> usize { .lines() .filter(|line| { let line = line.trim_start(); + if line.starts_with("pub type Stage") && line.contains("bolt_verifier_runtime::") { + return false; + } (line.starts_with("pub struct Stage") || line.starts_with("pub type Stage")) && PLAN_SUFFIXES.iter().any(|suffix| line.contains(suffix)) }) diff --git a/crates/jolt-equivalence/Cargo.toml b/crates/jolt-equivalence/Cargo.toml index 46207381dd..ba458b9f93 100644 --- a/crates/jolt-equivalence/Cargo.toml +++ b/crates/jolt-equivalence/Cargo.toml @@ -23,6 +23,7 @@ ark-serialize.workspace = true postcard.workspace = true # Bolt-generated Jolt path and shared modular primitives. +bolt-verifier-runtime.workspace = true common = { path = "../../common" } jolt-field = { path = "../jolt-field", features = ["bn254"] } jolt-transcript = { path = "../jolt-transcript" } diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index f2d0b4aa67..034020ae9d 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -1,8 +1,8 @@ //! Static plan adapters from Bolt compiler plans to generated/kernel plans. //! -//! These are compatibility shims for the equivalence oracle. They translate -//! Bolt's owned compiler plans into the currently generated static plan shape -//! expected by jolt-kernels, jolt-prover, and jolt-verifier. +//! The equivalence oracle compares Bolt's owned compiler plans against the +//! generated static plans expected by jolt-kernels, jolt-prover, and +//! jolt-verifier. These adapters keep that comparison explicit. macro_rules! stage_field_expr { (kernel, $module:ident, $field_expr:ident, $plan:ident) => { @@ -131,13 +131,11 @@ macro_rules! stage_driver { clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" )] -fn generated_program_step_kind(value: &str) -> jolt_verifier::stages::common::ProgramStepKind { +fn generated_program_step_kind(value: &str) -> bolt_verifier_runtime::ProgramStepKind { match value { - "transcript_squeeze" => jolt_verifier::stages::common::ProgramStepKind::TranscriptSqueeze, - "transcript_absorb_bytes" => { - jolt_verifier::stages::common::ProgramStepKind::TranscriptAbsorbBytes - } - "sumcheck_driver" => jolt_verifier::stages::common::ProgramStepKind::SumcheckDriver, + "transcript_squeeze" => bolt_verifier_runtime::ProgramStepKind::TranscriptSqueeze, + "transcript_absorb_bytes" => bolt_verifier_runtime::ProgramStepKind::TranscriptAbsorbBytes, + "sumcheck_driver" => bolt_verifier_runtime::ProgramStepKind::SumcheckDriver, value => panic!("unsupported generated program step kind `{value}`"), } } @@ -146,13 +144,11 @@ fn generated_program_step_kind(value: &str) -> jolt_verifier::stages::common::Pr clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" )] -fn generated_transcript_squeeze_kind( - value: &str, -) -> jolt_verifier::stages::common::TranscriptSqueezeKind { +fn generated_transcript_squeeze_kind(value: &str) -> bolt_verifier_runtime::TranscriptSqueezeKind { match value { - "challenge_scalar" => jolt_verifier::stages::common::TranscriptSqueezeKind::ChallengeScalar, - "challenge_vector" => jolt_verifier::stages::common::TranscriptSqueezeKind::ChallengeVector, - "scalar" => jolt_verifier::stages::common::TranscriptSqueezeKind::Scalar, + "challenge_scalar" => bolt_verifier_runtime::TranscriptSqueezeKind::ChallengeScalar, + "challenge_vector" => bolt_verifier_runtime::TranscriptSqueezeKind::ChallengeVector, + "scalar" => bolt_verifier_runtime::TranscriptSqueezeKind::Scalar, value => panic!("unsupported generated transcript squeeze kind `{value}`"), } } @@ -161,10 +157,10 @@ fn generated_transcript_squeeze_kind( clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" )] -fn generated_claim_kind(value: &str) -> jolt_verifier::stages::common::ClaimKind { +fn generated_claim_kind(value: &str) -> bolt_verifier_runtime::ClaimKind { match value { - "committed" => jolt_verifier::stages::common::ClaimKind::Committed, - "virtual" => jolt_verifier::stages::common::ClaimKind::Virtual, + "committed" => bolt_verifier_runtime::ClaimKind::Committed, + "virtual" => bolt_verifier_runtime::ClaimKind::Virtual, value => panic!("unsupported generated claim kind `{value}`"), } } @@ -173,81 +169,81 @@ fn generated_claim_kind(value: &str) -> jolt_verifier::stages::common::ClaimKind clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" )] -fn generated_relation_kind(value: &str) -> jolt_verifier::stages::common::RelationKind { +fn generated_relation_kind(value: &str) -> jolt_verifier::stages::jolt_relations::JoltRelationKind { match value { "jolt.stage1.outer.uniskip" => { - jolt_verifier::stages::common::RelationKind::Stage1OuterUniskip + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage1OuterUniskip } "jolt.stage1.outer.remaining" => { - jolt_verifier::stages::common::RelationKind::Stage1OuterRemaining + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage1OuterRemaining } "jolt.stage2.product_virtual.uniskip" => { - jolt_verifier::stages::common::RelationKind::Stage2ProductVirtualUniskip + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2ProductVirtualUniskip } "jolt.stage2.ram.read_write" => { - jolt_verifier::stages::common::RelationKind::Stage2RamReadWrite + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2RamReadWrite } "jolt.stage2.product_virtual.remainder" => { - jolt_verifier::stages::common::RelationKind::Stage2ProductVirtualRemainder + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2ProductVirtualRemainder } "jolt.stage2.instruction_lookup.claim_reduction" => { - jolt_verifier::stages::common::RelationKind::Stage2InstructionLookupClaimReduction + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2InstructionLookupClaimReduction } "jolt.stage2.ram.raf_evaluation" => { - jolt_verifier::stages::common::RelationKind::Stage2RamRafEvaluation + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2RamRafEvaluation } "jolt.stage2.ram.output_check" => { - jolt_verifier::stages::common::RelationKind::Stage2RamOutputCheck + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2RamOutputCheck } - "jolt.stage2.batched" => jolt_verifier::stages::common::RelationKind::Stage2Batched, + "jolt.stage2.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage2Batched, "jolt.stage3.spartan_shift" => { - jolt_verifier::stages::common::RelationKind::Stage3SpartanShift + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage3SpartanShift } "jolt.stage3.instruction_input" => { - jolt_verifier::stages::common::RelationKind::Stage3InstructionInput + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage3InstructionInput } "jolt.stage3.registers_claim_reduction" => { - jolt_verifier::stages::common::RelationKind::Stage3RegistersClaimReduction + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage3RegistersClaimReduction } - "jolt.stage3.batched" => jolt_verifier::stages::common::RelationKind::Stage3Batched, + "jolt.stage3.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage3Batched, "jolt.stage4.registers_read_write" => { - jolt_verifier::stages::common::RelationKind::Stage4RegistersReadWrite + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage4RegistersReadWrite } "jolt.stage4.ram_val_check" => { - jolt_verifier::stages::common::RelationKind::Stage4RamValCheck + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage4RamValCheck } - "jolt.stage4.batched" => jolt_verifier::stages::common::RelationKind::Stage4Batched, + "jolt.stage4.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage4Batched, "jolt.stage5.instruction_read_raf" => { - jolt_verifier::stages::common::RelationKind::Stage5InstructionReadRaf + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage5InstructionReadRaf } "jolt.stage5.ram_ra_claim_reduction" => { - jolt_verifier::stages::common::RelationKind::Stage5RamRaClaimReduction + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage5RamRaClaimReduction } "jolt.stage5.registers_val_evaluation" => { - jolt_verifier::stages::common::RelationKind::Stage5RegistersValEvaluation + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage5RegistersValEvaluation } - "jolt.stage5.batched" => jolt_verifier::stages::common::RelationKind::Stage5Batched, + "jolt.stage5.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage5Batched, "jolt.stage6.bytecode_read_raf" => { - jolt_verifier::stages::common::RelationKind::Stage6BytecodeReadRaf + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6BytecodeReadRaf } - "jolt.stage6.booleanity" => jolt_verifier::stages::common::RelationKind::Stage6Booleanity, + "jolt.stage6.booleanity" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6Booleanity, "jolt.stage6.hamming_booleanity" => { - jolt_verifier::stages::common::RelationKind::Stage6HammingBooleanity + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6HammingBooleanity } "jolt.stage6.ram_ra_virtual" => { - jolt_verifier::stages::common::RelationKind::Stage6RamRaVirtual + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6RamRaVirtual } "jolt.stage6.instruction_ra_virtual" => { - jolt_verifier::stages::common::RelationKind::Stage6InstructionRaVirtual + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6InstructionRaVirtual } "jolt.stage6.inc_claim_reduction" => { - jolt_verifier::stages::common::RelationKind::Stage6IncClaimReduction + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6IncClaimReduction } - "jolt.stage6.batched" => jolt_verifier::stages::common::RelationKind::Stage6Batched, + "jolt.stage6.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage6Batched, "jolt.stage7.hamming_weight_claim_reduction" => { - jolt_verifier::stages::common::RelationKind::Stage7HammingWeightClaimReduction + jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage7HammingWeightClaimReduction } - "jolt.stage7.batched" => jolt_verifier::stages::common::RelationKind::Stage7Batched, + "jolt.stage7.batched" => jolt_verifier::stages::jolt_relations::JoltRelationKind::Stage7Batched, value => panic!("unsupported generated relation `{value}`"), } } @@ -257,20 +253,20 @@ fn generated_relation_kind(value: &str) -> jolt_verifier::stages::common::Relati clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier field expression tag" )] -fn generated_field_expr_kind(value: &str) -> jolt_verifier::stages::common::FieldExprKind { +fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKind { match value { - "opening_eval" => jolt_verifier::stages::common::FieldExprKind::OpeningEval, - "field.add" => jolt_verifier::stages::common::FieldExprKind::Add, - "field.sub" => jolt_verifier::stages::common::FieldExprKind::Sub, - "field.mul" => jolt_verifier::stages::common::FieldExprKind::Mul, - "field.neg" => jolt_verifier::stages::common::FieldExprKind::Neg, + "opening_eval" => bolt_verifier_runtime::FieldExprKind::OpeningEval, + "field.add" => bolt_verifier_runtime::FieldExprKind::Add, + "field.sub" => bolt_verifier_runtime::FieldExprKind::Sub, + "field.mul" => bolt_verifier_runtime::FieldExprKind::Mul, + "field.neg" => bolt_verifier_runtime::FieldExprKind::Neg, value if value.starts_with("field.pow:") => { let exponent = value .strip_prefix("field.pow:") .expect("field pow expression has prefix") .parse::() .expect("field pow expression has usize exponent"); - jolt_verifier::stages::common::FieldExprKind::Pow(exponent) + bolt_verifier_runtime::FieldExprKind::Pow(exponent) } value if value.starts_with("poly.lagrange_basis_eval:") => { let spec = value @@ -278,7 +274,7 @@ fn generated_field_expr_kind(value: &str) -> jolt_verifier::stages::common::Fiel .expect("lagrange expression has prefix"); let parts = spec.split(':').collect::>(); assert!(parts.len() == 3, "lagrange expression has three fields"); - jolt_verifier::stages::common::FieldExprKind::LagrangeBasisEval( + bolt_verifier_runtime::FieldExprKind::LagrangeBasisEval( parts[0] .parse::() .expect("lagrange domain start is i64"), @@ -296,11 +292,9 @@ fn generated_field_expr_kind(value: &str) -> jolt_verifier::stages::common::Fiel clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" )] -fn generated_opening_equality_mode( - value: &str, -) -> jolt_verifier::stages::common::OpeningEqualityMode { +fn generated_opening_equality_mode(value: &str) -> bolt_verifier_runtime::OpeningEqualityMode { match value { - "point_and_eval" => jolt_verifier::stages::common::OpeningEqualityMode::PointAndEval, + "point_and_eval" => bolt_verifier_runtime::OpeningEqualityMode::PointAndEval, value => panic!("unsupported generated opening equality mode `{value}`"), } } diff --git a/crates/jolt-verifier/Cargo.toml b/crates/jolt-verifier/Cargo.toml index 3b6ecdafd5..df8f14efb2 100644 --- a/crates/jolt-verifier/Cargo.toml +++ b/crates/jolt-verifier/Cargo.toml @@ -10,6 +10,7 @@ repository = "https://github.com/a16z/jolt" workspace = true [dependencies] +bolt-verifier-runtime.workspace = true jolt-dory.workspace = true jolt-field.workspace = true jolt-lookup-tables.workspace = true diff --git a/crates/jolt-verifier/src/stages/common.rs b/crates/jolt-verifier/src/stages/common.rs deleted file mode 100644 index a5883c82ee..0000000000 --- a/crates/jolt-verifier/src/stages/common.rs +++ /dev/null @@ -1,1265 +0,0 @@ -#![expect( - clippy::too_many_arguments, - reason = "generated verifier helpers mirror staged protocol ABIs" -)] - -use std::fmt; -use std::marker::PhantomData; - -use jolt_field::{Field, Fr, MulPow2}; -use jolt_poly::lagrange::lagrange_evals; -use jolt_sumcheck::{ - CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier, -}; -use jolt_transcript::{Label, Transcript}; -use serde::Serialize; - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageParams { - pub field: &'static str, - pub pcs: &'static str, - pub transcript: &'static str, -} - -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] -pub struct TypedPlanSymbol { - symbol: &'static str, - _tag: PhantomData Tag>, -} - -impl TypedPlanSymbol { - pub const fn new(symbol: &'static str) -> Self { - Self { - symbol, - _tag: PhantomData, - } - } - - pub fn as_str(self) -> &'static str { - self.symbol - } -} - -impl fmt::Debug for TypedPlanSymbol { - fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { - formatter - .debug_tuple("TypedPlanSymbol") - .field(&self.symbol) - .finish() - } -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct KernelPlan { - pub symbol: &'static str, - pub relation: &'static str, - pub kind: &'static str, - pub backend: &'static str, - pub abi: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -#[rustfmt::skip] -pub enum RelationKind { Stage1OuterUniskip, Stage1OuterRemaining, Stage2ProductVirtualUniskip, Stage2RamReadWrite, Stage2ProductVirtualRemainder, Stage2InstructionLookupClaimReduction, Stage2RamRafEvaluation, Stage2RamOutputCheck, Stage2Batched, Stage3SpartanShift, Stage3InstructionInput, Stage3RegistersClaimReduction, Stage3Batched, Stage4RegistersReadWrite, Stage4RamValCheck, Stage4Batched, Stage5InstructionReadRaf, Stage5RamRaClaimReduction, Stage5RegistersValEvaluation, Stage5Batched, Stage6BytecodeReadRaf, Stage6Booleanity, Stage6HammingBooleanity, Stage6RamRaVirtual, Stage6InstructionRaVirtual, Stage6IncClaimReduction, Stage6Batched, Stage7HammingWeightClaimReduction, Stage7Batched } - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum TranscriptSqueezeKind { - ChallengeScalar, - ChallengeVector, - Scalar, -} - -impl TranscriptSqueezeKind { - pub fn is_scalar(self) -> bool { - matches!(self, Self::ChallengeScalar | Self::Scalar) - } -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct TranscriptSqueezePlan { - pub symbol: &'static str, - pub label: &'static str, - pub kind: TranscriptSqueezeKind, - pub count: usize, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct TranscriptAbsorbBytesPlan { - pub symbol: &'static str, - pub label: &'static str, - pub payload: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum ProgramStepKind { - TranscriptSqueeze, - TranscriptAbsorbBytes, - SumcheckDriver, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct ProgramStepPlan { - pub kind: ProgramStepKind, - pub symbol: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum ClaimKind { - Committed, - Virtual, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum SourceStage { - Stage6, - Stage7, -} - -impl SourceStage { - pub fn as_str(self) -> &'static str { - match self { - Self::Stage6 => "stage6", - Self::Stage7 => "stage7", - } - } -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum PcsProofMode { - Open, - Verify, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct OpeningInputPlan { - pub symbol: &'static str, - pub source_stage: &'static str, - pub source_claim: &'static str, - pub oracle: &'static str, - pub domain: &'static str, - pub point_arity: usize, - pub claim_kind: ClaimKind, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct FieldConstantPlan { - pub symbol: &'static str, - pub field: &'static str, - pub value: usize, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum FieldExprKind { - OpeningEval, - Add, - Sub, - Mul, - Neg, - Pow(usize), - LagrangeBasisEval(i64, usize, usize), -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct FieldExprPlan { - pub symbol: &'static str, - pub kind: FieldExprKind, - pub operands: &'static [&'static str], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckClaimPlan { - pub symbol: &'static str, - pub stage: &'static str, - pub domain: &'static str, - pub num_rounds: usize, - pub degree: usize, - pub claim: &'static str, - pub kernel: Option<&'static str>, - pub relation: Option, - pub claim_value: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckBatchPlan { - pub symbol: &'static str, - pub stage: &'static str, - pub proof_slot: &'static str, - pub policy: &'static str, - pub count: usize, - pub claim_operands: &'static [&'static str], - pub claim_label: &'static str, - pub round_label: &'static str, - pub round_schedule: &'static [usize], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckDriverPlan { - pub symbol: &'static str, - pub stage: &'static str, - pub proof_slot: &'static str, - pub kernel: Option<&'static str>, - pub relation: Option, - pub batch: &'static str, - pub policy: &'static str, - pub round_schedule: &'static [usize], - pub claim_label: &'static str, - pub round_label: &'static str, - pub num_rounds: usize, - pub degree: usize, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckInstanceResultPlan { - pub symbol: &'static str, - pub source: &'static str, - pub claim: &'static str, - pub relation: RelationKind, - pub index: usize, - pub point_arity: usize, - pub num_rounds: usize, - pub round_offset: usize, - pub point_order: &'static str, - pub degree: usize, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckEvalPlan { - pub symbol: &'static str, - pub source: &'static str, - pub name: &'static str, - pub index: usize, - pub oracle: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct PointZeroPlan { - pub symbol: &'static str, - pub field: &'static str, - pub arity: usize, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct PointSlicePlan { - pub symbol: &'static str, - pub source: &'static str, - pub offset: usize, - pub length: usize, - pub input: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct PointConcatPlan { - pub symbol: &'static str, - pub layout: &'static str, - pub arity: usize, - pub inputs: &'static [&'static str], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct OpeningClaimPlan { - pub symbol: &'static str, - pub oracle: &'static str, - pub domain: &'static str, - pub point_arity: usize, - pub claim_kind: ClaimKind, - pub point_source: &'static str, - pub eval_source: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum OpeningEqualityMode { - PointAndEval, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct OpeningClaimEqualityPlan { - pub symbol: &'static str, - pub mode: OpeningEqualityMode, - pub lhs: &'static str, - pub rhs: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct OpeningBatchPlan { - pub symbol: &'static str, - pub stage: &'static str, - pub proof_slot: &'static str, - pub policy: &'static str, - pub count: usize, - pub ordered_claims: &'static [&'static str], - pub claim_operands: &'static [&'static str], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageProgramPlan { - pub role: &'static str, - pub params: StageParams, - pub steps: &'static [ProgramStepPlan], - pub transcript_squeezes: &'static [TranscriptSqueezePlan], - pub transcript_absorb_bytes: &'static [TranscriptAbsorbBytesPlan], - pub opening_inputs: &'static [OpeningInputPlan], - pub field_constants: &'static [FieldConstantPlan], - pub field_exprs: &'static [FieldExprPlan], - pub kernels: &'static [KernelPlan], - pub claims: &'static [SumcheckClaimPlan], - pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], - pub evals: &'static [SumcheckEvalPlan], - pub point_zeros: &'static [PointZeroPlan], - pub point_slices: &'static [PointSlicePlan], - pub point_concats: &'static [PointConcatPlan], - pub opening_claims: &'static [OpeningClaimPlan], - pub opening_equalities: &'static [OpeningClaimEqualityPlan], - pub opening_batches: &'static [OpeningBatchPlan], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageProgramPlanNoPointZeros { - pub role: &'static str, - pub params: StageParams, - pub steps: &'static [ProgramStepPlan], - pub transcript_squeezes: &'static [TranscriptSqueezePlan], - pub transcript_absorb_bytes: &'static [TranscriptAbsorbBytesPlan], - pub opening_inputs: &'static [OpeningInputPlan], - pub field_constants: &'static [FieldConstantPlan], - pub field_exprs: &'static [FieldExprPlan], - pub kernels: &'static [KernelPlan], - pub claims: &'static [SumcheckClaimPlan], - pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], - pub evals: &'static [SumcheckEvalPlan], - pub point_slices: &'static [PointSlicePlan], - pub point_concats: &'static [PointConcatPlan], - pub opening_claims: &'static [OpeningClaimPlan], - pub opening_equalities: &'static [OpeningClaimEqualityPlan], - pub opening_batches: &'static [OpeningBatchPlan], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageVerifierProgramPlan { - pub params: StageParams, - pub steps: &'static [ProgramStepPlan], - pub transcript_squeezes: &'static [TranscriptSqueezePlan], - pub opening_inputs: &'static [OpeningInputPlan], - pub field_constants: &'static [FieldConstantPlan], - pub field_exprs: &'static [FieldExprPlan], - pub claims: &'static [SumcheckClaimPlan], - pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], - pub evals: &'static [SumcheckEvalPlan], - pub point_slices: &'static [PointSlicePlan], - pub point_concats: &'static [PointConcatPlan], - pub opening_claims: &'static [OpeningClaimPlan], - pub opening_equalities: &'static [OpeningClaimEqualityPlan], - pub opening_batches: &'static [OpeningBatchPlan], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageVerifierProgramPlanNoEqualities { - pub params: StageParams, - pub steps: &'static [ProgramStepPlan], - pub transcript_squeezes: &'static [TranscriptSqueezePlan], - pub opening_inputs: &'static [OpeningInputPlan], - pub field_constants: &'static [FieldConstantPlan], - pub field_exprs: &'static [FieldExprPlan], - pub claims: &'static [SumcheckClaimPlan], - pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], - pub evals: &'static [SumcheckEvalPlan], - pub point_slices: &'static [PointSlicePlan], - pub point_concats: &'static [PointConcatPlan], - pub opening_claims: &'static [OpeningClaimPlan], - pub opening_batches: &'static [OpeningBatchPlan], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct VerifierProgramPlanMinimal { - pub params: StageParams, - pub transcript_squeezes: &'static [TranscriptSqueezePlan], - pub claims: &'static [SumcheckClaimPlan], - pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], - pub evals: &'static [SumcheckEvalPlan], - pub opening_claims: &'static [OpeningClaimPlan], - pub opening_batches: &'static [OpeningBatchPlan], -} - -#[derive(Clone, Debug, PartialEq, Eq, Serialize)] -pub struct StageNamedEval { - pub name: &'static str, - pub oracle: &'static str, - pub value: F, -} - -#[derive(Clone, Debug, Serialize)] -pub struct StageSumcheckOutput { - pub driver: &'static str, - pub point: Vec, - pub evals: Vec>, - pub proof: SumcheckProof, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct StageChallengeVector { - pub symbol: &'static str, - pub values: Vec, -} - -#[derive(Clone, Debug)] -pub struct StageExecutionArtifacts { - pub challenge_vectors: Vec>, - pub sumchecks: Vec>, - pub opening_batches: Vec<&'static OpeningBatchPlan>, -} - -impl Default for StageExecutionArtifacts { - fn default() -> Self { - Self { - challenge_vectors: Vec::new(), - sumchecks: Vec::new(), - opening_batches: Vec::new(), - } - } -} - -#[derive(Clone, Debug, Default, Serialize)] -pub struct StageProof { - pub sumchecks: Vec>, -} - -#[derive(Clone, Debug)] -pub struct StageOpeningInputValue { - pub symbol: &'static str, - pub point: Vec, - pub eval: F, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum RuntimePlanError { - MissingBatch { - driver: &'static str, - batch: &'static str, - }, - MissingClaim { - batch: &'static str, - claim: &'static str, - }, - MissingValue { - symbol: &'static str, - }, - InvalidInputLength { - input: &'static str, - expected: usize, - actual: usize, - }, - InvalidProof { - driver: &'static str, - reason: &'static str, - }, -} - -macro_rules! impl_runtime_plan_error_conversion { - ($error:ident) => { - impl From for $error { - fn from(error: super::common::RuntimePlanError) -> Self { - match error { - super::common::RuntimePlanError::MissingBatch { driver, batch } => { - Self::MissingBatch { driver, batch } - } - super::common::RuntimePlanError::MissingClaim { batch, claim } => { - Self::MissingClaim { batch, claim } - } - super::common::RuntimePlanError::MissingValue { symbol } => { - Self::MissingValue { symbol } - } - super::common::RuntimePlanError::InvalidInputLength { - input, - expected, - actual, - } => Self::InvalidInputLength { - input, - expected, - actual, - }, - super::common::RuntimePlanError::InvalidProof { driver, reason } => { - Self::InvalidProof { driver, reason } - } - } - } - } - }; -} - -pub(crate) use impl_runtime_plan_error_conversion; - -pub trait SymbolPlan { - fn symbol(&self) -> &'static str; -} - -impl SymbolPlan for TranscriptSqueezePlan { - fn symbol(&self) -> &'static str { - self.symbol - } -} - -impl SymbolPlan for TranscriptAbsorbBytesPlan { - fn symbol(&self) -> &'static str { - self.symbol - } -} - -impl SymbolPlan for SumcheckBatchPlan { - fn symbol(&self) -> &'static str { - self.symbol - } -} - -impl SymbolPlan for SumcheckClaimPlan { - fn symbol(&self) -> &'static str { - self.symbol - } -} - -impl SymbolPlan for SumcheckDriverPlan { - fn symbol(&self) -> &'static str { - self.symbol - } -} - -impl SymbolPlan for OpeningClaimPlan { - fn symbol(&self) -> &'static str { - self.symbol - } -} - -pub trait SumcheckClaimInfo: SymbolPlan { - fn num_rounds(&self) -> usize; - fn claim_value(&self) -> &'static str; -} - -impl SumcheckClaimInfo for SumcheckClaimPlan { - fn num_rounds(&self) -> usize { - self.num_rounds - } - - fn claim_value(&self) -> &'static str { - self.claim_value - } -} - -pub trait SumcheckDriverInfo: SymbolPlan { - fn batch(&self) -> &'static str; - fn num_rounds(&self) -> usize; - fn degree(&self) -> usize; - fn round_label(&self) -> &'static str; -} - -impl SumcheckDriverInfo for SumcheckDriverPlan { - fn batch(&self) -> &'static str { - self.batch - } - - fn num_rounds(&self) -> usize { - self.num_rounds - } - - fn degree(&self) -> usize { - self.degree - } - - fn round_label(&self) -> &'static str { - self.round_label - } -} - -#[derive(Clone, Debug, Default)] -pub struct ValueStore { - scalars: Vec<(&'static str, F)>, - points: Vec<(&'static str, Vec)>, -} - -impl ValueStore { - pub fn with_opening_inputs( - inputs: &[StageOpeningInputValue], - expected_inputs: &[OpeningInputPlan], - ) -> Result { - if inputs.len() != expected_inputs.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: "opening_inputs", - expected: expected_inputs.len(), - actual: inputs.len(), - }); - } - for expected in expected_inputs { - let matching_count = inputs - .iter() - .filter(|input| input.symbol == expected.symbol) - .count(); - if matching_count != 1 { - return Err(RuntimePlanError::InvalidInputLength { - input: expected.symbol, - expected: 1, - actual: matching_count, - }); - } - if let Some(input) = inputs.iter().find(|input| input.symbol == expected.symbol) { - if input.point.len() != expected.point_arity { - return Err(RuntimePlanError::InvalidInputLength { - input: expected.symbol, - expected: expected.point_arity, - actual: input.point.len(), - }); - } - } - } - let mut store = Self::default(); - for input in inputs { - store.insert_scalar(input.symbol, input.eval); - store.insert_point(input.symbol, input.point.clone()); - } - Ok(store) - } - - pub fn seed_constants(&mut self, constants: &[FieldConstantPlan]) { - for constant in constants { - self.insert_scalar(constant.symbol, F::from_u64(constant.value as u64)); - } - } - - pub fn seed_point_zeros(&mut self, point_zeros: &[PointZeroPlan]) { - for zero in point_zeros { - self.insert_point(zero.symbol, vec![F::from_u64(0); zero.arity]); - } - } - - pub fn observe_challenge_vector( - &mut self, - plan: &TranscriptSqueezePlan, - values: &[F], - invalid_input_length: impl Fn(&'static str, usize, usize) -> E, - ) -> Result<(), E> { - self.insert_point(plan.symbol, values.to_vec()); - if plan.kind.is_scalar() { - if values.len() != 1 { - return Err(invalid_input_length(plan.symbol, 1, values.len())); - } - self.insert_scalar(plan.symbol, values[0]); - } - Ok(()) - } - - pub fn observe_sumcheck_output( - &mut self, - instance_results: &[SumcheckInstanceResultPlan], - evals: &[SumcheckEvalPlan], - output: &StageSumcheckOutput, - normalize_point: impl Fn(&SumcheckInstanceResultPlan, Vec) -> Result, E>, - invalid_input_length: impl Fn(&'static str, usize, usize) -> E, - missing_value: impl Fn(&'static str) -> E, - ) -> Result<(), E> { - self.insert_point(output.driver, output.point.clone()); - for instance in instance_results - .iter() - .filter(|instance| instance.source == output.driver) - { - let end = instance.round_offset + instance.point_arity; - let point = output - .point - .get(instance.round_offset..end) - .ok_or_else(|| invalid_input_length(instance.symbol, end, output.point.len()))? - .to_vec(); - self.insert_point(instance.symbol, normalize_point(instance, point)?); - } - for eval in evals.iter().filter(|eval| eval.source == output.driver) { - let value = output - .evals - .iter() - .find(|value| value.name == eval.name) - .or_else(|| output.evals.get(eval.index)) - .ok_or_else(|| missing_value(eval.symbol))? - .value; - self.insert_scalar(eval.symbol, value); - self.insert_scalar(eval.name, value); - } - Ok(()) - } - - pub fn evaluate_available_points( - &mut self, - point_slices: &[PointSlicePlan], - point_concats: &[PointConcatPlan], - invalid_input_length: impl Fn(&'static str, usize, usize) -> E, - ) -> Result<(), E> { - loop { - let mut progress = 0usize; - for slice in point_slices { - if self.try_point(slice.symbol).is_some() { - continue; - } - let Some(input) = self.try_point(slice.input) else { - continue; - }; - let end = slice.offset + slice.length; - let point = input - .get(slice.offset..end) - .ok_or_else(|| invalid_input_length(slice.symbol, end, input.len()))? - .to_vec(); - self.insert_point(slice.symbol, point); - progress += 1; - } - for concat in point_concats { - if self.try_point(concat.symbol).is_some() { - continue; - } - let Some(point) = self.try_concat_point(concat) else { - continue; - }; - if point.len() != concat.arity { - return Err(invalid_input_length( - concat.symbol, - concat.arity, - point.len(), - )); - } - self.insert_point(concat.symbol, point); - progress += 1; - } - if progress == 0 { - return Ok(()); - } - } - } - - pub fn evaluate_available_field_exprs( - &mut self, - field_exprs: &[FieldExprPlan], - evaluate: impl Fn(&FieldExprPlan, &[F]) -> Result, - ) -> Result<(), E> { - loop { - let mut progress = 0usize; - for expr in field_exprs { - if self.try_scalar(expr.symbol).is_some() { - continue; - } - let Some(operands) = self.try_expr_operands(expr) else { - continue; - }; - self.insert_scalar(expr.symbol, evaluate(expr, &operands)?); - progress += 1; - } - if progress == 0 { - return Ok(()); - } - } - } - - pub fn verify_opening_equalities( - &self, - opening_equalities: &[OpeningClaimEqualityPlan], - invalid_proof: impl Fn(&'static str, &'static str) -> E, - missing_value: impl Fn(&'static str) -> E, - ) -> Result<(), E> { - for equality in opening_equalities { - match equality.mode { - OpeningEqualityMode::PointAndEval => { - if self.point_or(equality.lhs, &missing_value)? - != self.point_or(equality.rhs, &missing_value)? - || self.scalar_or(equality.lhs, &missing_value)? - != self.scalar_or(equality.rhs, &missing_value)? - { - return Err(invalid_proof( - equality.symbol, - "opening claim equality failed", - )); - } - } - } - } - Ok(()) - } - - pub fn insert_scalar(&mut self, symbol: &'static str, value: F) { - if let Some((_, existing)) = self.scalars.iter_mut().find(|(name, _)| *name == symbol) { - *existing = value; - } else { - self.scalars.push((symbol, value)); - } - } - - pub fn insert_point(&mut self, symbol: &'static str, point: Vec) { - if let Some((_, existing)) = self.points.iter_mut().find(|(name, _)| *name == symbol) { - *existing = point; - } else { - self.points.push((symbol, point)); - } - } - - pub fn scalar_or( - &self, - symbol: &'static str, - missing_value: impl FnOnce(&'static str) -> E, - ) -> Result { - self.try_scalar(symbol).ok_or_else(|| missing_value(symbol)) - } - - pub fn try_scalar(&self, symbol: &str) -> Option { - self.scalars - .iter() - .find(|(name, _)| *name == symbol) - .map(|(_, value)| *value) - } - - pub fn point_or( - &self, - symbol: &'static str, - missing_value: impl FnOnce(&'static str) -> E, - ) -> Result<&[F], E> { - self.try_point(symbol).ok_or_else(|| missing_value(symbol)) - } - - pub fn try_point(&self, symbol: &str) -> Option<&[F]> { - self.points - .iter() - .find(|(name, _)| *name == symbol) - .map(|(_, point)| point.as_slice()) - } - - fn try_expr_operands(&self, expr: &FieldExprPlan) -> Option> { - expr.operands - .iter() - .map(|operand| self.try_scalar(operand)) - .collect() - } - - fn try_concat_point(&self, concat: &PointConcatPlan) -> Option> { - let mut point = Vec::with_capacity(concat.arity); - for input in concat.inputs { - point.extend_from_slice(self.try_point(input)?); - } - Some(point) - } -} - -pub fn find_plan<'a, T: SymbolPlan>(plans: &'a [T], symbol: &str) -> Option<&'a T> { - plans.iter().find(|plan| plan.symbol() == symbol) -} - -pub fn find_batch<'a>( - batches: &'a [SumcheckBatchPlan], - driver: &'static str, - batch: &'static str, -) -> Result<&'a SumcheckBatchPlan, RuntimePlanError> { - find_plan(batches, batch).ok_or(RuntimePlanError::MissingBatch { driver, batch }) -} - -pub fn batch_claims<'a, C: SymbolPlan>( - claims: &'a [C], - batch: &SumcheckBatchPlan, -) -> Result, RuntimePlanError> { - batch - .claim_operands - .iter() - .copied() - .map(|symbol| { - find_plan(claims, symbol).ok_or(RuntimePlanError::MissingClaim { - batch: batch.symbol, - claim: symbol, - }) - }) - .collect() -} - -pub fn batch_claim_values( - claims: &[&C], - field_exprs: &[FieldExprPlan], - store: &mut ValueStore, -) -> Result, RuntimePlanError> { - claims - .iter() - .map(|claim| { - store.evaluate_available_field_exprs(field_exprs, evaluate_field_expr)?; - store.scalar_or(claim.claim_value(), |symbol| { - RuntimePlanError::MissingValue { symbol } - }) - }) - .collect() -} - -pub fn verify_batched_sumcheck( - driver: &'static D, - proof: &StageSumcheckOutput, - claims: &'static [C], - batches: &'static [SumcheckBatchPlan], - field_exprs: &'static [FieldExprPlan], - opening_inputs: &'static [OpeningInputPlan], - opening_claims: &'static [OpeningClaimPlan], - opening_batches: &'static [OpeningBatchPlan], - store: &mut ValueStore, - transcript: &mut T, - expected_output: Expected, - observe_output: Observe, - map_sumcheck: MapSumcheck, -) -> Result, E> -where - T: Transcript, - E: From, - C: SumcheckClaimInfo, - D: SumcheckDriverInfo, - Expected: FnOnce(&ValueStore, &[StageNamedEval], &[Fr], &[Fr]) -> Result, - Observe: FnOnce(&mut ValueStore, &StageSumcheckOutput) -> Result<(), E>, - MapSumcheck: FnOnce(&'static str, SumcheckError) -> E, -{ - if proof.driver != driver.symbol() { - return Err(RuntimePlanError::InvalidProof { - driver: driver.symbol(), - reason: "driver symbol mismatch", - } - .into()); - } - let batch = find_batch(batches, driver.symbol(), driver.batch())?; - let claims = batch_claims(claims, batch)?; - let input_claims = batch_claim_values(&claims, field_exprs, store)?; - for claim in &input_claims { - append_labeled_scalar(transcript, batch.claim_label, claim); - } - let batching_coeffs = transcript.challenge_vector(claims.len()); - let claimed_sum = input_claims - .iter() - .zip(claims.iter()) - .zip(&batching_coeffs) - .map(|((claim, plan), coefficient)| { - claim.mul_pow_2(driver.num_rounds() - plan.num_rounds()) * *coefficient - }) - .sum::(); - let claim = SumcheckClaim::new(driver.num_rounds(), driver.degree(), claimed_sum); - let round_proofs = proof - .proof - .round_polynomials - .iter() - .map(|poly| CompressedLabeledRoundPoly::new(poly, driver.round_label().as_bytes())) - .collect::>(); - let output = SumcheckVerifier::verify_optimized(&claim, &round_proofs, transcript) - .map_err(|error| map_sumcheck(driver.symbol(), error))?; - if !proof.point.is_empty() && proof.point != output.point { - return Err(RuntimePlanError::InvalidProof { - driver: driver.symbol(), - reason: "batched point mismatch", - } - .into()); - } - let expected = expected_output(store, &proof.evals, &output.point, &batching_coeffs)?; - if output.value != expected { - return Err(RuntimePlanError::InvalidProof { - driver: driver.symbol(), - reason: "batched output claim mismatch", - } - .into()); - } - let verified = StageSumcheckOutput { - driver: driver.symbol(), - point: output.point, - evals: proof.evals.clone(), - proof: proof.proof.clone(), - }; - observe_output(store, &verified)?; - append_opening_claims( - opening_inputs, - opening_claims, - opening_batches, - store, - transcript, - &verified.evals, - |batch, claim| RuntimePlanError::MissingClaim { batch, claim }, - |symbol| RuntimePlanError::MissingValue { symbol }, - )?; - Ok(verified) -} - -pub fn eval_by_name( - evals: &[StageNamedEval], - name: &'static str, -) -> Result { - evals - .iter() - .find(|eval| eval.name == name) - .map(|eval| eval.value) - .ok_or(RuntimePlanError::MissingValue { symbol: name }) -} - -pub fn indexed_evals_by_prefix( - evals: &[StageNamedEval], - prefix: &'static str, - count: usize, -) -> Result, RuntimePlanError> { - let mut values = vec![None; count]; - for eval in evals { - let Some(suffix) = eval.name.strip_prefix(prefix) else { - continue; - }; - let index = suffix - .parse::() - .map_err(|_| RuntimePlanError::InvalidProof { - driver: prefix, - reason: "invalid indexed eval suffix", - })?; - if index >= count || values[index].is_some() { - return Err(RuntimePlanError::InvalidProof { - driver: prefix, - reason: "invalid indexed eval", - }); - } - values[index] = Some(eval.value); - } - values - .into_iter() - .map(|value| value.ok_or(RuntimePlanError::MissingValue { symbol: prefix })) - .collect() -} - -pub fn indexed_evals_by_prefix_any( - evals: &[StageNamedEval], - prefix: &'static str, -) -> Result, RuntimePlanError> { - let mut indexed_values = Vec::new(); - for eval in evals { - let Some(suffix) = eval.name.strip_prefix(prefix) else { - continue; - }; - let index = suffix - .parse::() - .map_err(|_| RuntimePlanError::InvalidProof { - driver: prefix, - reason: "invalid indexed eval suffix", - })?; - if indexed_values - .iter() - .any(|(existing_index, _)| *existing_index == index) - { - return Err(RuntimePlanError::InvalidProof { - driver: prefix, - reason: "duplicate indexed eval", - }); - } - indexed_values.push((index, eval.value)); - } - if indexed_values.is_empty() { - return Err(RuntimePlanError::MissingValue { symbol: prefix }); - } - indexed_values.sort_by_key(|(index, _)| *index); - for (expected, (actual, _)) in indexed_values.iter().enumerate() { - if *actual != expected { - return Err(RuntimePlanError::InvalidProof { - driver: prefix, - reason: "non-contiguous indexed eval", - }); - } - } - Ok(indexed_values.into_iter().map(|(_, value)| value).collect()) -} - -pub fn single_operand( - symbol: &'static str, - operands: &[F], -) -> Result { - require_operand_count(symbol, 1, operands.len())?; - Ok(operands[0]) -} - -pub fn require_operand_count( - input: &'static str, - expected: usize, - actual: usize, -) -> Result<(), RuntimePlanError> { - if expected == actual { - Ok(()) - } else { - Err(RuntimePlanError::InvalidInputLength { - input, - expected, - actual, - }) - } -} - -pub fn evaluate_field_expr( - expr: &FieldExprPlan, - operands: &[F], -) -> Result { - match expr.kind { - FieldExprKind::OpeningEval => Ok(single_operand(expr.symbol, operands)?), - FieldExprKind::Add => { - require_operand_count(expr.symbol, 2, operands.len())?; - Ok(operands[0] + operands[1]) - } - FieldExprKind::Sub => { - require_operand_count(expr.symbol, 2, operands.len())?; - Ok(operands[0] - operands[1]) - } - FieldExprKind::Mul => { - require_operand_count(expr.symbol, 2, operands.len())?; - Ok(operands[0] * operands[1]) - } - FieldExprKind::Neg => { - require_operand_count(expr.symbol, 1, operands.len())?; - Ok(-operands[0]) - } - FieldExprKind::Pow(exponent) => { - require_operand_count(expr.symbol, 1, operands.len())?; - Ok(pow_field(operands[0], exponent)) - } - FieldExprKind::LagrangeBasisEval(domain_start, domain_size, index) => { - require_operand_count(expr.symbol, 1, operands.len())?; - let weights = lagrange_evals(domain_start, domain_size, operands[0]); - weights - .get(index) - .copied() - .ok_or(RuntimePlanError::InvalidInputLength { - input: expr.symbol, - expected: index + 1, - actual: weights.len(), - }) - } - } -} - -pub fn indexed_boolean_eq(index: usize, point: &[Fr]) -> Fr { - point - .iter() - .enumerate() - .map(|(bit, value)| { - if (index >> (point.len() - 1 - bit)) & 1 == 1 { - *value - } else { - Fr::from_u64(1) - *value - } - }) - .product() -} - -pub fn field_powers(base: Fr, count: usize) -> Vec { - let mut powers = Vec::with_capacity(count); - let mut power = Fr::from_u64(1); - for _ in 0..count { - powers.push(power); - power *= base; - } - powers -} - -pub fn prefix_point<'a, F: Field>( - point: &'a [F], - length: usize, - input: &'static str, -) -> Result<&'a [F], RuntimePlanError> { - point - .get(..length) - .filter(|prefix| prefix.len() == length) - .ok_or(RuntimePlanError::InvalidInputLength { - input, - expected: length, - actual: point.len(), - }) -} - -pub fn suffix_point<'a, F: Field>( - point: &'a [F], - length: usize, - input: &'static str, -) -> Result<&'a [F], RuntimePlanError> { - point - .get(point.len().saturating_sub(length)..) - .filter(|suffix| suffix.len() == length) - .ok_or(RuntimePlanError::InvalidInputLength { - input, - expected: length, - actual: point.len(), - }) -} - -pub fn store_scalar(store: &ValueStore, symbol: &'static str) -> Result { - store.scalar_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol }) -} - -pub fn store_point<'a>( - store: &'a ValueStore, - symbol: &'static str, -) -> Result<&'a [Fr], RuntimePlanError> { - store.point_or(symbol, |symbol| RuntimePlanError::MissingValue { symbol }) -} - -pub fn append_labeled_scalar(transcript: &mut T, label: &'static str, scalar: &Fr) -where - T: Transcript, -{ - transcript.append(&Label(label.as_bytes())); - transcript.append(scalar); -} - -pub fn append_opening_claims( - opening_inputs: &[OpeningInputPlan], - opening_claims: &[OpeningClaimPlan], - opening_batches: &[OpeningBatchPlan], - store: &mut ValueStore, - transcript: &mut T, - evals: &[StageNamedEval], - missing_claim: impl Fn(&'static str, &'static str) -> E, - missing_value: impl Fn(&'static str) -> E, -) -> Result<(), E> -where - T: Transcript, -{ - if opening_batches.is_empty() { - for eval in evals { - append_labeled_scalar(transcript, "opening_claim", &eval.value); - } - return Ok(()); - } - let mut seen = opening_inputs - .iter() - .filter_map(|input| { - store - .try_point(input.symbol) - .map(|point| (input.claim_kind, input.oracle, point.to_vec())) - }) - .collect::>(); - for batch in opening_batches { - for &symbol in batch.claim_operands { - let claim = opening_claims - .iter() - .find(|claim| claim.symbol == symbol) - .ok_or_else(|| missing_claim(batch.symbol, symbol))?; - let point = store.point_or(claim.point_source, &missing_value)?.to_vec(); - if seen.iter().any(|(kind, oracle, seen_point)| { - *kind == claim.claim_kind && *oracle == claim.oracle && seen_point == &point - }) { - continue; - } - let value = store.scalar_or(claim.eval_source, &missing_value)?; - append_labeled_scalar(transcript, "opening_claim", &value); - seen.push((claim.claim_kind, claim.oracle, point)); - } - } - Ok(()) -} - -pub fn pow_field(base: F, mut exponent: usize) -> F { - let mut result = F::one(); - let mut power = base; - while exponent != 0 { - if exponent & 1 == 1 { - result *= power; - } - power = power.square(); - exponent >>= 1; - } - result -} - -pub fn reverse_slice(values: &[Fr]) -> Vec { - values.iter().rev().copied().collect() -} diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index f812297135..89a427cc27 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -23,19 +23,23 @@ //! Treat changes here as Jolt protocol changes, not as compiler-output //! cleanups. Generic Bolt verifier scaffolding (typed plan structs, //! `ValueStore`, generic sumcheck verification, generic field-expr -//! dispatch) lives in `super::common` instead. +//! dispatch) lives in `bolt_verifier_runtime` instead. //! //! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition. use jolt_field::{Field, Fr, MulPow2, RingCore}; use jolt_poly::EqPolynomial; -use super::common::{ +use bolt_verifier_runtime::{ eval_by_name, field_powers, indexed_boolean_eq, indexed_evals_by_prefix_any, prefix_point, - reverse_slice, store_point, store_scalar, suffix_point, OpeningInputPlan, RelationKind, - RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, + reverse_slice, store_point, store_scalar, suffix_point, OpeningInputPlan, RuntimePlanError, + StageNamedEval, SumcheckInstanceResultPlan, ValueStore, }; +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[rustfmt::skip] +pub enum JoltRelationKind { Stage1OuterUniskip, Stage1OuterRemaining, Stage2ProductVirtualUniskip, Stage2RamReadWrite, Stage2ProductVirtualRemainder, Stage2InstructionLookupClaimReduction, Stage2RamRafEvaluation, Stage2RamOutputCheck, Stage2Batched, Stage3SpartanShift, Stage3InstructionInput, Stage3RegistersClaimReduction, Stage3Batched, Stage4RegistersReadWrite, Stage4RamValCheck, Stage4Batched, Stage5InstructionReadRaf, Stage5RamRaClaimReduction, Stage5RegistersValEvaluation, Stage5Batched, Stage6BytecodeReadRaf, Stage6Booleanity, Stage6HammingBooleanity, Stage6RamRaVirtual, Stage6InstructionRaVirtual, Stage6IncClaimReduction, Stage6Batched, Stage7HammingWeightClaimReduction, Stage7Batched } + pub fn bytecode_gamma_powers(gamma: Fr) -> [Fr; 8] { let mut powers = [Fr::from_u64(1); 8]; for index in 1..powers.len() { @@ -142,12 +146,12 @@ pub trait Stage67BytecodeEntry { } pub fn stage67_trace_rounds( - instance_results: &[SumcheckInstanceResultPlan], + instance_results: &[SumcheckInstanceResultPlan], symbols: &Stage67RelationSymbols, ) -> Result { instance_results .iter() - .find(|instance| instance.relation == RelationKind::Stage6HammingBooleanity) + .find(|instance| instance.relation == JoltRelationKind::Stage6HammingBooleanity) .map(|instance| instance.num_rounds) .ok_or(RuntimePlanError::MissingValue { symbol: symbols.hamming_booleanity_instance, diff --git a/crates/jolt-verifier/src/stages/mod.rs b/crates/jolt-verifier/src/stages/mod.rs index 5650b56cd8..c29b7b6bfc 100644 --- a/crates/jolt-verifier/src/stages/mod.rs +++ b/crates/jolt-verifier/src/stages/mod.rs @@ -1,4 +1,3 @@ -pub mod common; pub mod jolt_relations; #[rustfmt::skip] pub mod commitment; diff --git a/crates/jolt-verifier/src/stages/stage1_outer.rs b/crates/jolt-verifier/src/stages/stage1_outer.rs index d8aaf5b608..a6b0786bf7 100644 --- a/crates/jolt-verifier/src/stages/stage1_outer.rs +++ b/crates/jolt-verifier/src/stages/stage1_outer.rs @@ -1,29 +1,30 @@ #![allow(dead_code)] -use super::common::append_labeled_scalar; +use bolt_verifier_runtime::append_labeled_scalar; use jolt_field::Fr; use jolt_sumcheck::{CompressedLabeledRoundPoly, LabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier}; use jolt_transcript::{Blake2bTranscript, Transcript}; pub type DefaultStage1Transcript = Blake2bTranscript; -pub type Stage1Params = super::common::StageParams; -pub type Stage1NamedEval = super::common::StageNamedEval; -pub type Stage1SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage1ChallengeVector = super::common::StageChallengeVector; -pub type Stage1ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage1Proof = super::common::StageProof; -pub type Stage1VerifierProgramPlan = super::common::VerifierProgramPlanMinimal; +pub type Stage1Params = bolt_verifier_runtime::StageParams; +pub type Stage1NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage1SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage1ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage1ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage1Proof = bolt_verifier_runtime::StageProof; +pub type Stage1VerifierProgramPlan = bolt_verifier_runtime::VerifierProgramPlanMinimal; +pub type Stage1SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage1SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage1SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub use super::common::{ - ClaimKind as Stage1ClaimKind, RelationKind as Stage1RelationKind, OpeningBatchPlan as Stage1OpeningBatchPlan, +pub use super::jolt_relations::JoltRelationKind as Stage1RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage1ClaimKind, OpeningBatchPlan as Stage1OpeningBatchPlan, OpeningClaimPlan as Stage1OpeningClaimPlan, SumcheckBatchPlan as Stage1SumcheckBatchPlan, SumcheckEvalPlan as Stage1SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage1SumcheckInstanceResultPlan, TranscriptSqueezeKind as Stage1TranscriptSqueezeKind, TranscriptSqueezePlan as Stage1TranscriptSqueezePlan, - SumcheckClaimPlan as Stage1SumcheckClaimPlan, - SumcheckDriverPlan as Stage1SumcheckDriverPlan, }; #[derive(Debug)] diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index 46480478b1..4bbfd8221f 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use super::common::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; +use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt, RingCore}; use jolt_poly::lagrange::{lagrange_evals, lagrange_kernel_eval}; use jolt_poly::{EqPolynomial, UnivariatePoly}; @@ -9,16 +9,20 @@ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; pub type DefaultStage2Transcript = Blake2bTranscript; -pub type Stage2NamedEval = super::common::StageNamedEval; -pub type Stage2SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage2ChallengeVector = super::common::StageChallengeVector; -pub type Stage2ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage2Proof = super::common::StageProof; -pub type Stage2OpeningInputValue = super::common::StageOpeningInputValue; -pub type Stage2VerifierProgramPlan = super::common::StageVerifierProgramPlanNoEqualities; - -pub use super::common::{ - ClaimKind as Stage2ClaimKind, RelationKind as Stage2RelationKind, FieldConstantPlan as Stage2FieldConstantPlan, +pub type Stage2NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage2SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage2ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage2ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage2Proof = bolt_verifier_runtime::StageProof; +pub type Stage2OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage2VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlanNoEqualities; +pub type Stage2SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage2SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage2SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage2RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage2ClaimKind, FieldConstantPlan as Stage2FieldConstantPlan, FieldExprKind as Stage2FieldExprKind, FieldExprPlan as Stage2FieldExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, @@ -27,11 +31,8 @@ pub use super::common::{ ProgramStepPlan as Stage2ProgramStepPlan, StageParams as Stage2Params, SumcheckBatchPlan as Stage2SumcheckBatchPlan, SumcheckEvalPlan as Stage2SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage2SumcheckInstanceResultPlan, TranscriptSqueezeKind as Stage2TranscriptSqueezeKind, TranscriptSqueezePlan as Stage2TranscriptSqueezePlan, - SumcheckClaimPlan as Stage2SumcheckClaimPlan, - SumcheckDriverPlan as Stage2SumcheckDriverPlan, }; #[derive(Clone, Copy, Debug)] @@ -58,7 +59,7 @@ pub struct Stage2RamData<'a> { } #[derive(Clone, Debug, Default)] -struct Stage2ValueStore(super::common::ValueStore); +struct Stage2ValueStore(bolt_verifier_runtime::ValueStore); #[derive(Debug)] pub enum VerifyStage2Error { @@ -74,7 +75,7 @@ pub enum VerifyStage2Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage2Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); pub const STAGE2_PARAMS: Stage2Params = Stage2Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE2_PROGRAM_STEPS: &[Stage2ProgramStepPlan] = &[ @@ -496,7 +497,7 @@ where proof: proof.proof.clone(), }; store.observe_sumcheck_output(program, &verified)?; - super::common::append_opening_claims( + bolt_verifier_runtime::append_opening_claims( program.opening_inputs, program.opening_claims, program.opening_batches, @@ -514,7 +515,7 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, inputs: &[Stage2OpeningInputValue], ) -> Result { - Ok(Self(super::common::ValueStore::with_opening_inputs( + Ok(Self(bolt_verifier_runtime::ValueStore::with_opening_inputs( inputs, program.opening_inputs, )?)) @@ -620,7 +621,7 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, ) -> Result<(), VerifyStage2Error> { self.0 - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage2Error::from) } diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index fe0929f4a8..e45b6e0c53 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; +use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; use jolt_field::{Field, Fr}; use jolt_poly::{EqPlusOnePolynomial, EqPolynomial}; use jolt_sumcheck::SumcheckError; @@ -8,16 +8,20 @@ use jolt_transcript::{Blake2bTranscript, Transcript}; pub type DefaultStage3Transcript = Blake2bTranscript; -pub type Stage3NamedEval = super::common::StageNamedEval; -pub type Stage3SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage3ChallengeVector = super::common::StageChallengeVector; -pub type Stage3ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage3Proof = super::common::StageProof; -pub type Stage3OpeningInputValue = super::common::StageOpeningInputValue; -pub type Stage3VerifierProgramPlan = super::common::StageVerifierProgramPlan; +pub type Stage3NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage3SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage3ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage3ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage3Proof = bolt_verifier_runtime::StageProof; +pub type Stage3OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage3VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlan; +pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage3SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub use super::common::{ - ClaimKind as Stage3ClaimKind, RelationKind as Stage3RelationKind, FieldConstantPlan as Stage3FieldConstantPlan, +pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage3ClaimKind, FieldConstantPlan as Stage3FieldConstantPlan, FieldExprKind as Stage3FieldExprKind, FieldExprPlan as Stage3FieldExprPlan, OpeningBatchPlan as Stage3OpeningBatchPlan, @@ -28,11 +32,8 @@ pub use super::common::{ ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage3SumcheckInstanceResultPlan, TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, - SumcheckClaimPlan as Stage3SumcheckClaimPlan, - SumcheckDriverPlan as Stage3SumcheckDriverPlan, }; #[derive(Debug)] @@ -48,7 +49,7 @@ pub enum VerifyStage3Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage3Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); pub const STAGE3_PARAMS: Stage3Params = Stage3Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[ @@ -224,7 +225,7 @@ where }); } let mut store = - super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; + bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); let mut artifacts = Stage3ExecutionArtifacts::default(); for step in program.steps { @@ -264,7 +265,7 @@ pub fn stage3_verifier_program() -> &'static Stage3VerifierProgramPlan { fn verify_stage3_squeeze( program: &'static Stage3VerifierProgramPlan, squeeze: &'static Stage3TranscriptSqueezePlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage3ExecutionArtifacts, ) -> Result<(), VerifyStage3Error> @@ -280,7 +281,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage3Error::from)?; artifacts.challenge_vectors.push(Stage3ChallengeVector { symbol: squeeze.symbol, @@ -293,7 +294,7 @@ fn verify_stage3_driver( program: &'static Stage3VerifierProgramPlan, driver: &'static Stage3SumcheckDriverPlan, proof: &Stage3Proof, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage3ExecutionArtifacts, ) -> Result<(), VerifyStage3Error> @@ -326,13 +327,13 @@ fn verify_batched_stage3( program: &'static Stage3VerifierProgramPlan, driver: &'static Stage3SumcheckDriverPlan, proof: &Stage3SumcheckOutput, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, ) -> Result, VerifyStage3Error> where T: Transcript, { - super::common::verify_batched_sumcheck( + bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, program.claims, @@ -353,7 +354,7 @@ where fn observe_stage3_sumcheck_output( program: &'static Stage3VerifierProgramPlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, output: &Stage3SumcheckOutput, ) -> Result<(), VerifyStage3Error> { store.observe_sumcheck_output( @@ -390,7 +391,7 @@ fn observe_stage3_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage3Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -402,7 +403,7 @@ fn observe_stage3_sumcheck_output( fn expected_batched_output_claim( program: &'static Stage3VerifierProgramPlan, driver: &'static Stage3SumcheckDriverPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage3NamedEval], point: &[Fr], batching_coeffs: &[Fr], @@ -444,42 +445,42 @@ fn expected_batched_output_claim( } fn expected_spartan_shift( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage3NamedEval], local_point: &[Fr], ) -> Result { let opening_point = reverse_slice(local_point); let eq_outer = - EqPlusOnePolynomial::::new(super::common::store_point(store, "stage3.input.stage1.NextPC")?.to_vec()) + EqPlusOnePolynomial::::new(bolt_verifier_runtime::store_point(store, "stage3.input.stage1.NextPC")?.to_vec()) .evaluate(&opening_point); let eq_product = EqPlusOnePolynomial::::new( - super::common::store_point(store, "stage3.input.stage2.product_virtual.NextIsNoop")? + bolt_verifier_runtime::store_point(store, "stage3.input.stage2.product_virtual.NextIsNoop")? .to_vec(), ) .evaluate(&opening_point); let weighted_outer = eval_by_name(evals, "stage3.spartan_shift.eval.UnexpandedPC")? - + super::common::store_scalar(store, "stage3.spartan_shift.gamma")? + + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma")? * eval_by_name(evals, "stage3.spartan_shift.eval.PC")? - + super::common::store_scalar(store, "stage3.spartan_shift.gamma2")? + + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma2")? * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagVirtualInstruction")? - + super::common::store_scalar(store, "stage3.spartan_shift.gamma3")? + + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma3")? * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagIsFirstInSequence")?; Ok(eq_outer * weighted_outer - + super::common::store_scalar(store, "stage3.spartan_shift.gamma4")? + + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma4")? * eq_product * (Fr::from_u64(1) - eval_by_name(evals, "stage3.spartan_shift.eval.InstructionFlagIsNoop")?)) } fn expected_instruction_input( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage3NamedEval], local_point: &[Fr], ) -> Result { let opening_point = reverse_slice(local_point); let eq_eval = EqPolynomial::::mle( &opening_point, - super::common::store_point(store, "stage3.input.stage2.product_virtual.LeftInstructionInput")?, + bolt_verifier_runtime::store_point(store, "stage3.input.stage2.product_virtual.LeftInstructionInput")?, ); let left = eval_by_name( evals, @@ -497,23 +498,23 @@ fn expected_instruction_input( evals, "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", )? * eval_by_name(evals, "stage3.instruction_input.eval.Imm")?; - Ok(eq_eval * (right + super::common::store_scalar(store, "stage3.instruction_input.gamma")? * left)) + Ok(eq_eval * (right + bolt_verifier_runtime::store_scalar(store, "stage3.instruction_input.gamma")? * left)) } fn expected_registers( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage3NamedEval], local_point: &[Fr], ) -> Result { let opening_point = reverse_slice(local_point); let eq_eval = EqPolynomial::::mle( &opening_point, - super::common::store_point(store, "stage3.input.stage1.RdWriteValue")?, + bolt_verifier_runtime::store_point(store, "stage3.input.stage1.RdWriteValue")?, ); Ok(eq_eval * (eval_by_name(evals, "stage3.registers_claim_reduction.eval.RdWriteValue")? - + super::common::store_scalar(store, "stage3.registers.gamma")? + + bolt_verifier_runtime::store_scalar(store, "stage3.registers.gamma")? * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs1Value")? - + super::common::store_scalar(store, "stage3.registers.gamma2")? + + bolt_verifier_runtime::store_scalar(store, "stage3.registers.gamma2")? * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs2Value")?)) } diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index d373b7205c..a18b126caa 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -1,21 +1,26 @@ #![allow(dead_code)] -use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; +use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; use super::jolt_relations::lt_polynomial_eval; use jolt_field::{Field, Fr}; use jolt_poly::EqPolynomial; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; -pub type Stage4NamedEval = super::common::StageNamedEval; -pub type Stage4SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage4ChallengeVector = super::common::StageChallengeVector; -pub type Stage4ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage4Proof = super::common::StageProof; -pub type Stage4OpeningInputValue = super::common::StageOpeningInputValue; - -pub use super::common::{ - ClaimKind as Stage4ClaimKind, RelationKind as Stage4RelationKind, FieldConstantPlan as Stage4FieldConstantPlan, +pub type Stage4NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage4SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage4ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage4ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage4Proof = bolt_verifier_runtime::StageProof; +pub type Stage4OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZeros; +pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage4SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage4ClaimKind, FieldConstantPlan as Stage4FieldConstantPlan, FieldExprKind as Stage4FieldExprKind, FieldExprPlan as Stage4FieldExprPlan, KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan, @@ -25,11 +30,8 @@ pub use super::common::{ PointConcatPlan as Stage4PointConcatPlan, PointSlicePlan as Stage4PointSlicePlan, ProgramStepKind as Stage4ProgramStepKind, ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, - StageProgramPlanNoPointZeros as Stage4CpuProgramPlan, SumcheckBatchPlan as Stage4SumcheckBatchPlan, - SumcheckClaimPlan as Stage4SumcheckClaimPlan, SumcheckDriverPlan as Stage4SumcheckDriverPlan, SumcheckEvalPlan as Stage4SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage4SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage4TranscriptSqueezeKind, TranscriptSqueezePlan as Stage4TranscriptSqueezePlan, @@ -51,7 +53,7 @@ pub enum VerifyStage4Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage4Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); pub const STAGE4_PARAMS: Stage4Params = Stage4Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE4_PROGRAM_STEPS: &[Stage4ProgramStepPlan] = &[ @@ -204,7 +206,7 @@ where }); } let mut store = - super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; + bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); let mut artifacts = Stage4ExecutionArtifacts::default(); for step in program.steps { @@ -246,7 +248,7 @@ pub fn stage4_verifier_program() -> &'static Stage4VerifierProgramPlan { fn verify_stage4_squeeze( program: &'static Stage4VerifierProgramPlan, squeeze: &'static Stage4TranscriptSqueezePlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage4ExecutionArtifacts, ) -> Result<(), VerifyStage4Error> @@ -262,7 +264,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage4Error::from)?; artifacts.challenge_vectors.push(Stage4ChallengeVector { symbol: squeeze.symbol, @@ -286,7 +288,7 @@ fn verify_stage4_driver( program: &'static Stage4VerifierProgramPlan, driver: &'static Stage4SumcheckDriverPlan, proof: &Stage4Proof, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage4ExecutionArtifacts, ) -> Result<(), VerifyStage4Error> @@ -319,13 +321,13 @@ fn verify_batched_stage4( program: &'static Stage4VerifierProgramPlan, driver: &'static Stage4SumcheckDriverPlan, proof: &Stage4SumcheckOutput, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, ) -> Result, VerifyStage4Error> where T: Transcript, { - super::common::verify_batched_sumcheck( + bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, program.claims, @@ -346,7 +348,7 @@ where fn observe_stage4_sumcheck_output( program: &'static Stage4VerifierProgramPlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, output: &Stage4SumcheckOutput, ) -> Result<(), VerifyStage4Error> { store.observe_sumcheck_output( @@ -386,7 +388,7 @@ fn observe_stage4_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage4Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -398,7 +400,7 @@ fn observe_stage4_sumcheck_output( fn expected_batched_output_claim( program: &'static Stage4VerifierProgramPlan, driver: &'static Stage4SumcheckDriverPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage4NamedEval], point: &[Fr], batching_coeffs: &[Fr], @@ -443,11 +445,11 @@ fn expected_batched_output_claim( } fn expected_registers_read_write( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage4NamedEval], local_point: &[Fr], ) -> Result { - let trace_point = super::common::store_point(store, "stage4.input.stage3.registers.RdWriteValue")?; + let trace_point = bolt_verifier_runtime::store_point(store, "stage4.input.stage3.registers.RdWriteValue")?; let r_cycle = normalize_stage4_registers_rw_cycle_point( local_point, trace_point.len(), @@ -462,18 +464,18 @@ fn expected_registers_read_write( let rs2_ra = eval_by_name(evals, "stage4.registers_read_write.eval.Rs2Ra")?; let rd_wa = eval_by_name(evals, "stage4.registers_read_write.eval.RdWa")?; let rd_inc = eval_by_name(evals, "stage4.registers_read_write.eval.RdInc")?; - let gamma = super::common::store_scalar(store, "stage4.registers_read_write.gamma")?; + let gamma = bolt_verifier_runtime::store_scalar(store, "stage4.registers_read_write.gamma")?; Ok(eq_eval * (rd_wa * (registers_val + rd_inc) + gamma * (rs1_ra * registers_val + gamma * rs2_ra * registers_val))) } fn expected_ram_val_check( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage4NamedEval], local_point: &[Fr], ) -> Result { - let ram_val_point = super::common::store_point(store, "stage4.input.stage2.RamVal")?; + let ram_val_point = bolt_verifier_runtime::store_point(store, "stage4.input.stage2.RamVal")?; let r_cycle_prime = reverse_slice(local_point); let r_cycle = suffix_point( ram_val_point, @@ -481,7 +483,7 @@ fn expected_ram_val_check( "stage4.input.stage2.RamVal", )?; let lt_eval = lt_polynomial_eval(&r_cycle_prime, r_cycle); - let gamma = super::common::store_scalar(store, "stage4.ram_val_check.gamma")?; + let gamma = bolt_verifier_runtime::store_scalar(store, "stage4.ram_val_check.gamma")?; let ram_ra = eval_by_name(evals, "stage4.ram_val_check.eval.RamRa")?; let ram_inc = eval_by_name(evals, "stage4.ram_val_check.eval.RamInc")?; Ok(ram_inc * ram_ra * (lt_eval + gamma)) diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 4f4a426915..c7a473b8a1 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use super::common::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice, suffix_point}; +use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice, suffix_point}; use super::jolt_relations::{identity_polynomial_eval, lt_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval}; use jolt_field::{Field, Fr, RingCore}; use jolt_lookup_tables::LookupTableKind; @@ -8,15 +8,20 @@ use jolt_poly::EqPolynomial; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; -pub type Stage5NamedEval = super::common::StageNamedEval; -pub type Stage5SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage5ChallengeVector = super::common::StageChallengeVector; -pub type Stage5ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage5Proof = super::common::StageProof; -pub type Stage5OpeningInputValue = super::common::StageOpeningInputValue; - -pub use super::common::{ - ClaimKind as Stage5ClaimKind, RelationKind as Stage5RelationKind, FieldConstantPlan as Stage5FieldConstantPlan, +pub type Stage5NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage5SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage5ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage5ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage5Proof = bolt_verifier_runtime::StageProof; +pub type Stage5OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZeros; +pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage5SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage5RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage5ClaimKind, FieldConstantPlan as Stage5FieldConstantPlan, FieldExprKind as Stage5FieldExprKind, FieldExprPlan as Stage5FieldExprPlan, KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan, @@ -26,11 +31,8 @@ pub use super::common::{ PointConcatPlan as Stage5PointConcatPlan, PointSlicePlan as Stage5PointSlicePlan, ProgramStepKind as Stage5ProgramStepKind, ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params, - StageProgramPlanNoPointZeros as Stage5CpuProgramPlan, SumcheckBatchPlan as Stage5SumcheckBatchPlan, - SumcheckClaimPlan as Stage5SumcheckClaimPlan, SumcheckDriverPlan as Stage5SumcheckDriverPlan, SumcheckEvalPlan as Stage5SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage5SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage5TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage5TranscriptSqueezeKind, TranscriptSqueezePlan as Stage5TranscriptSqueezePlan, @@ -52,7 +54,7 @@ pub enum VerifyStage5Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage5Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); pub const STAGE5_PARAMS: Stage5Params = Stage5Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE5_PROGRAM_STEPS: &[Stage5ProgramStepPlan] = &[ @@ -316,7 +318,7 @@ where }); } let mut store = - super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; + bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); let mut artifacts = Stage5ExecutionArtifacts::default(); for step in program.steps { @@ -358,7 +360,7 @@ pub fn stage5_verifier_program() -> &'static Stage5VerifierProgramPlan { fn verify_stage5_squeeze( program: &'static Stage5VerifierProgramPlan, squeeze: &'static Stage5TranscriptSqueezePlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage5ExecutionArtifacts, ) -> Result<(), VerifyStage5Error> @@ -374,7 +376,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage5Error::from)?; artifacts.challenge_vectors.push(Stage5ChallengeVector { symbol: squeeze.symbol, @@ -398,7 +400,7 @@ fn verify_stage5_driver( program: &'static Stage5VerifierProgramPlan, driver: &'static Stage5SumcheckDriverPlan, proof: &Stage5Proof, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage5ExecutionArtifacts, ) -> Result<(), VerifyStage5Error> @@ -431,13 +433,13 @@ fn verify_batched_stage5( program: &'static Stage5VerifierProgramPlan, driver: &'static Stage5SumcheckDriverPlan, proof: &Stage5SumcheckOutput, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, ) -> Result, VerifyStage5Error> where T: Transcript, { - super::common::verify_batched_sumcheck( + bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, program.claims, @@ -458,7 +460,7 @@ where fn observe_stage5_sumcheck_output( program: &'static Stage5VerifierProgramPlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, output: &Stage5SumcheckOutput, ) -> Result<(), VerifyStage5Error> { store.observe_sumcheck_output( @@ -498,7 +500,7 @@ fn observe_stage5_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage5Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -510,7 +512,7 @@ fn observe_stage5_sumcheck_output( fn expected_batched_output_claim( program: &'static Stage5VerifierProgramPlan, driver: &'static Stage5SumcheckDriverPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage5NamedEval], point: &[Fr], batching_coeffs: &[Fr], @@ -558,7 +560,7 @@ fn expected_batched_output_claim( } fn expected_instruction_read_raf( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage5NamedEval], local_point: &[Fr], ) -> Result { @@ -575,7 +577,7 @@ fn expected_instruction_read_raf( let (r_address_prime, r_cycle) = local_point.split_at(LOG_K); let r_cycle_prime = reverse_slice(r_cycle); - let r_reduction = super::common::store_point(store, "stage5.input.stage2.instruction.LookupOutput")?; + let r_reduction = bolt_verifier_runtime::store_point(store, "stage5.input.stage2.instruction.LookupOutput")?; let eq_eval_r_reduction = EqPolynomial::::mle(r_reduction, &r_cycle_prime); let left_operand_eval = operand_polynomial_eval(r_address_prime, true); @@ -607,7 +609,7 @@ fn expected_instruction_read_raf( evals, "stage5.instruction_read_raf.eval.InstructionRafFlag", )?; - let gamma = super::common::store_scalar(store, "stage5.instruction_read_raf.gamma")?; + let gamma = bolt_verifier_runtime::store_scalar(store, "stage5.instruction_read_raf.gamma")?; let raf_claim = (Fr::from_u64(1) - raf_flag_claim) * (left_operand_eval + gamma * right_operand_eval) @@ -616,27 +618,27 @@ fn expected_instruction_read_raf( } fn expected_ram_ra_claim_reduction( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage5NamedEval], local_point: &[Fr], ) -> Result { let r_cycle_reduced = reverse_slice(local_point); let r_cycle_raf = suffix_point( - super::common::store_point(store, "stage5.input.stage2.ram_raf.RamRa")?, + bolt_verifier_runtime::store_point(store, "stage5.input.stage2.ram_raf.RamRa")?, r_cycle_reduced.len(), "stage5.input.stage2.ram_raf.RamRa", )?; let r_cycle_rw = suffix_point( - super::common::store_point(store, "stage5.input.stage2.ram_read_write.RamRa")?, + bolt_verifier_runtime::store_point(store, "stage5.input.stage2.ram_read_write.RamRa")?, r_cycle_reduced.len(), "stage5.input.stage2.ram_read_write.RamRa", )?; let r_cycle_val = suffix_point( - super::common::store_point(store, "stage5.input.stage4.ram_val_check.RamRa")?, + bolt_verifier_runtime::store_point(store, "stage5.input.stage4.ram_val_check.RamRa")?, r_cycle_reduced.len(), "stage5.input.stage4.ram_val_check.RamRa", )?; - let gamma = super::common::store_scalar(store, "stage5.ram_ra_claim_reduction.gamma")?; + let gamma = bolt_verifier_runtime::store_scalar(store, "stage5.ram_ra_claim_reduction.gamma")?; let eq_combined = EqPolynomial::::mle(r_cycle_raf, &r_cycle_reduced) + gamma * EqPolynomial::::mle(r_cycle_rw, &r_cycle_reduced) + gamma.square() * EqPolynomial::::mle(r_cycle_val, &r_cycle_reduced); @@ -645,11 +647,11 @@ fn expected_ram_ra_claim_reduction( } fn expected_registers_val_evaluation( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage5NamedEval], local_point: &[Fr], ) -> Result { - let registers_val_point = super::common::store_point(store, "stage5.input.stage4.registers.RegistersVal")?; + let registers_val_point = bolt_verifier_runtime::store_point(store, "stage5.input.stage4.registers.RegistersVal")?; let r_cycle = suffix_point( registers_val_point, local_point.len(), diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index ca7d2d7894..ecba02932b 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1,20 +1,25 @@ #![allow(dead_code)] -use super::common::{batch_claims, find_batch, find_plan}; +use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; use super::jolt_relations::{expected_stage67_booleanity, expected_stage67_bytecode_read_raf, expected_stage67_hamming_booleanity, expected_stage67_inc_claim_reduction, expected_stage67_instruction_ra_virtual, expected_stage67_ram_ra_virtual, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; -pub type Stage6NamedEval = super::common::StageNamedEval; -pub type Stage6SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage6ChallengeVector = super::common::StageChallengeVector; -pub type Stage6ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage6Proof = super::common::StageProof; -pub type Stage6OpeningInputValue = super::common::StageOpeningInputValue; - -pub use super::common::{ - ClaimKind as Stage6ClaimKind, RelationKind as Stage6RelationKind, FieldConstantPlan as Stage6FieldConstantPlan, +pub type Stage6NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage6SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage6ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage6ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage6Proof = bolt_verifier_runtime::StageProof; +pub type Stage6OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage6CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; +pub type Stage6SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage6SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage6SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage6RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage6ClaimKind, FieldConstantPlan as Stage6FieldConstantPlan, FieldExprKind as Stage6FieldExprKind, FieldExprPlan as Stage6FieldExprPlan, KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan, @@ -24,11 +29,9 @@ pub use super::common::{ PointConcatPlan as Stage6PointConcatPlan, PointSlicePlan as Stage6PointSlicePlan, PointZeroPlan as Stage6PointZeroPlan, ProgramStepKind as Stage6ProgramStepKind, ProgramStepPlan as Stage6ProgramStepPlan, - StageParams as Stage6Params, StageProgramPlan as Stage6CpuProgramPlan, + StageParams as Stage6Params, SumcheckBatchPlan as Stage6SumcheckBatchPlan, - SumcheckClaimPlan as Stage6SumcheckClaimPlan, SumcheckDriverPlan as Stage6SumcheckDriverPlan, SumcheckEvalPlan as Stage6SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage6SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage6TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage6TranscriptSqueezeKind, TranscriptSqueezePlan as Stage6TranscriptSqueezePlan, @@ -152,7 +155,7 @@ pub enum VerifyStage6Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage6Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); pub const STAGE6_PARAMS: Stage6Params = Stage6Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE6_PROGRAM_STEPS: &[Stage6ProgramStepPlan] = &[ @@ -646,7 +649,7 @@ where }); } let mut store = - super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; + bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); store.seed_point_zeros(program.point_zeros); let mut artifacts = Stage6ExecutionArtifacts::default(); @@ -697,7 +700,7 @@ pub fn stage6_verifier_program() -> &'static Stage6VerifierProgramPlan { fn verify_stage6_squeeze( program: &'static Stage6VerifierProgramPlan, squeeze: &'static Stage6TranscriptSqueezePlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage6ExecutionArtifacts, ) -> Result<(), VerifyStage6Error> @@ -717,7 +720,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage6Error::from)?; artifacts.challenge_vectors.push(Stage6ChallengeVector { symbol: squeeze.symbol, @@ -742,7 +745,7 @@ fn verify_stage6_driver( driver: &'static Stage6SumcheckDriverPlan, proof: &Stage6Proof, verifier_data: Option<&Stage6VerifierData>, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage6ExecutionArtifacts, ) -> Result<(), VerifyStage6Error> @@ -776,13 +779,13 @@ fn verify_batched_stage6( driver: &'static Stage6SumcheckDriverPlan, proof: &Stage6SumcheckOutput, verifier_data: Option<&Stage6VerifierData>, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, ) -> Result, VerifyStage6Error> where T: Transcript, { - super::common::verify_batched_sumcheck( + bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, program.claims, @@ -811,7 +814,7 @@ where fn observe_stage6_sumcheck_output( program: &'static Stage6VerifierProgramPlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, output: &Stage6SumcheckOutput, ) -> Result<(), VerifyStage6Error> { store.observe_sumcheck_output( @@ -851,7 +854,7 @@ fn observe_stage6_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage6Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -864,7 +867,7 @@ fn expected_batched_output_claim( program: &'static Stage6VerifierProgramPlan, driver: &'static Stage6SumcheckDriverPlan, verifier_data: Option<&Stage6VerifierData>, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], point: &[Fr], batching_coeffs: &[Fr], @@ -928,7 +931,7 @@ fn expected_batched_output_claim( fn expected_bytecode_read_raf( program: &'static Stage6VerifierProgramPlan, data: &Stage6BytecodeReadRafData, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { @@ -947,7 +950,7 @@ fn expected_bytecode_read_raf( fn expected_booleanity( program: &'static Stage6VerifierProgramPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { @@ -956,7 +959,7 @@ fn expected_booleanity( } fn expected_hamming_booleanity( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { @@ -964,7 +967,7 @@ fn expected_hamming_booleanity( } fn expected_ram_ra_virtual( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { @@ -973,7 +976,7 @@ fn expected_ram_ra_virtual( fn expected_instruction_ra_virtual( program: &'static Stage6VerifierProgramPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { @@ -981,7 +984,7 @@ fn expected_instruction_ra_virtual( } fn expected_inc_claim_reduction( - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 3d3c193144..67c1785aae 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -1,20 +1,25 @@ #![allow(dead_code)] -use super::common::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; +use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; use jolt_field::{Field, Fr, RingCore}; use jolt_poly::EqPolynomial; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; -pub type Stage7NamedEval = super::common::StageNamedEval; -pub type Stage7SumcheckOutput = super::common::StageSumcheckOutput; -pub type Stage7ChallengeVector = super::common::StageChallengeVector; -pub type Stage7ExecutionArtifacts = super::common::StageExecutionArtifacts; -pub type Stage7Proof = super::common::StageProof; -pub type Stage7OpeningInputValue = super::common::StageOpeningInputValue; - -pub use super::common::{ - ClaimKind as Stage7ClaimKind, RelationKind as Stage7RelationKind, FieldConstantPlan as Stage7FieldConstantPlan, +pub type Stage7NamedEval = bolt_verifier_runtime::StageNamedEval; +pub type Stage7SumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type Stage7ChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type Stage7ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type Stage7Proof = bolt_verifier_runtime::StageProof; +pub type Stage7OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; +pub type Stage7CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; +pub type Stage7SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; +pub type Stage7SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; +pub type Stage7SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; + +pub use super::jolt_relations::JoltRelationKind as Stage7RelationKind; +pub use bolt_verifier_runtime::{ + ClaimKind as Stage7ClaimKind, FieldConstantPlan as Stage7FieldConstantPlan, FieldExprKind as Stage7FieldExprKind, FieldExprPlan as Stage7FieldExprPlan, KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan, @@ -24,11 +29,9 @@ pub use super::common::{ PointConcatPlan as Stage7PointConcatPlan, PointSlicePlan as Stage7PointSlicePlan, PointZeroPlan as Stage7PointZeroPlan, ProgramStepKind as Stage7ProgramStepKind, ProgramStepPlan as Stage7ProgramStepPlan, - StageParams as Stage7Params, StageProgramPlan as Stage7CpuProgramPlan, + StageParams as Stage7Params, SumcheckBatchPlan as Stage7SumcheckBatchPlan, - SumcheckClaimPlan as Stage7SumcheckClaimPlan, SumcheckDriverPlan as Stage7SumcheckDriverPlan, SumcheckEvalPlan as Stage7SumcheckEvalPlan, - SumcheckInstanceResultPlan as Stage7SumcheckInstanceResultPlan, TranscriptAbsorbBytesPlan as Stage7TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage7TranscriptSqueezeKind, TranscriptSqueezePlan as Stage7TranscriptSqueezePlan, @@ -50,7 +53,7 @@ pub enum VerifyStage7Error { Sumcheck { driver: &'static str, error: SumcheckError }, } -super::common::impl_runtime_plan_error_conversion!(VerifyStage7Error); +bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); pub const STAGE7_PARAMS: Stage7Params = Stage7Params { field: "bn254_fr", pcs: "dory", transcript: "blake2b_transcript" }; pub const STAGE7_PROGRAM_STEPS: &[Stage7ProgramStepPlan] = &[ @@ -354,7 +357,7 @@ where }); } let mut store = - super::common::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; + bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); store.seed_point_zeros(program.point_zeros); let mut artifacts = Stage7ExecutionArtifacts::default(); @@ -404,7 +407,7 @@ pub fn stage7_verifier_program() -> &'static Stage7VerifierProgramPlan { fn verify_stage7_squeeze( program: &'static Stage7VerifierProgramPlan, squeeze: &'static Stage7TranscriptSqueezePlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage7ExecutionArtifacts, ) -> Result<(), VerifyStage7Error> @@ -420,7 +423,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage7Error::from)?; artifacts.challenge_vectors.push(Stage7ChallengeVector { symbol: squeeze.symbol, @@ -444,7 +447,7 @@ fn verify_stage7_driver( program: &'static Stage7VerifierProgramPlan, driver: &'static Stage7SumcheckDriverPlan, proof: &Stage7Proof, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, artifacts: &mut Stage7ExecutionArtifacts, ) -> Result<(), VerifyStage7Error> @@ -477,13 +480,13 @@ fn verify_batched_stage7( program: &'static Stage7VerifierProgramPlan, driver: &'static Stage7SumcheckDriverPlan, proof: &Stage7SumcheckOutput, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, transcript: &mut T, ) -> Result, VerifyStage7Error> where T: Transcript, { - super::common::verify_batched_sumcheck( + bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, program.claims, @@ -504,7 +507,7 @@ where fn observe_stage7_sumcheck_output( program: &'static Stage7VerifierProgramPlan, - store: &mut super::common::ValueStore, + store: &mut bolt_verifier_runtime::ValueStore, output: &Stage7SumcheckOutput, ) -> Result<(), VerifyStage7Error> { store.observe_sumcheck_output( @@ -542,7 +545,7 @@ fn observe_stage7_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, super::common::evaluate_field_expr) + .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) .map_err(VerifyStage7Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -554,7 +557,7 @@ fn observe_stage7_sumcheck_output( fn expected_batched_output_claim( program: &'static Stage7VerifierProgramPlan, driver: &'static Stage7SumcheckDriverPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage7NamedEval], point: &[Fr], batching_coeffs: &[Fr], @@ -598,12 +601,12 @@ fn expected_batched_output_claim( fn expected_hamming_weight_claim_reduction( program: &'static Stage7VerifierProgramPlan, driver: &'static Stage7SumcheckDriverPlan, - store: &super::common::ValueStore, + store: &bolt_verifier_runtime::ValueStore, evals: &[Stage7NamedEval], local_point: &[Fr], ) -> Result { let rho_rev = reverse_slice(local_point); - let booleanity_point = super::common::store_point(store, "stage7.input.stage6.booleanity.InstructionRa_0")?; + let booleanity_point = bolt_verifier_runtime::store_point(store, "stage7.input.stage6.booleanity.InstructionRa_0")?; let r_addr_bool = booleanity_point .get(..local_point.len()) @@ -613,7 +616,7 @@ fn expected_hamming_weight_claim_reduction( actual: booleanity_point.len(), })?; let eq_bool = EqPolynomial::::mle(&rho_rev, r_addr_bool); - let gamma = super::common::store_scalar(store, "stage7.hamming_weight_claim_reduction.gamma")?; + let gamma = bolt_verifier_runtime::store_scalar(store, "stage7.hamming_weight_claim_reduction.gamma")?; let mut gamma_power = Fr::from_u64(1); let mut expected = Fr::from_u64(0); let mut eval_plans = program @@ -637,7 +640,7 @@ fn expected_hamming_weight_claim_reduction( } fn stage7_virtualization_point<'a>( - store: &'a super::common::ValueStore, + store: &'a bolt_verifier_runtime::ValueStore, oracle: &str, log_k_chunk: usize, ) -> Result<&'a [Fr], VerifyStage7Error> { diff --git a/crates/jolt-verifier/src/stages/stage8.rs b/crates/jolt-verifier/src/stages/stage8.rs index afd2239aac..5d8a79c12c 100644 --- a/crates/jolt-verifier/src/stages/stage8.rs +++ b/crates/jolt-verifier/src/stages/stage8.rs @@ -1,6 +1,21 @@ #![allow(clippy::too_many_lines)] -pub use super::common::{ClaimKind as Stage8ClaimKind, PcsProofMode as Stage8PcsProofMode, SourceStage as Stage8SourceStage, StageParams as Stage8Params, TypedPlanSymbol}; +pub use bolt_verifier_runtime::{ClaimKind as Stage8ClaimKind, PcsProofMode as Stage8PcsProofMode, StageParams as Stage8Params, TypedPlanSymbol}; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage8SourceStage { + Stage6, + Stage7, +} + +impl Stage8SourceStage { + pub fn as_str(self) -> &'static str { + match self { + Self::Stage6 => "stage6", + Self::Stage7 => "stage7", + } + } +} #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub enum Stage8OpeningInputTag {} diff --git a/crates/jolt-verifier/src/verifier.rs b/crates/jolt-verifier/src/verifier.rs index ede5adcc39..5b997c13c6 100644 --- a/crates/jolt-verifier/src/verifier.rs +++ b/crates/jolt-verifier/src/verifier.rs @@ -8,9 +8,9 @@ use jolt_transcript::Transcript; use crate::stages::{commitment as commitment_stage, stage1_outer as stage1_outer_stage, stage2 as stage2_stage, stage3 as stage3_stage, stage4 as stage4_stage, stage5 as stage5_stage, stage6 as stage6_stage, stage7 as stage7_stage, stage8 as stage8_stage}; -pub type JoltNamedEval = crate::stages::common::StageNamedEval; -pub type JoltSumcheckOutput = crate::stages::common::StageSumcheckOutput; -pub type JoltStageProof = crate::stages::common::StageProof; +pub type JoltNamedEval = bolt_verifier_runtime::StageNamedEval; +pub type JoltSumcheckOutput = bolt_verifier_runtime::StageSumcheckOutput; +pub type JoltStageProof = bolt_verifier_runtime::StageProof; #[derive(Clone, Debug)] pub struct JoltProof { @@ -28,9 +28,9 @@ pub struct JoltProof { pub type JoltStage2RamAccess = crate::stages::stage2::Stage2RamAccess; pub type JoltStage2RamOutputLayout = crate::stages::stage2::Stage2RamOutputLayout; pub type JoltStage2RamData<'a> = crate::stages::stage2::Stage2RamData<'a>; -pub type JoltStageChallengeVector = crate::stages::common::StageChallengeVector; -pub type JoltStageExecutionArtifacts = crate::stages::common::StageExecutionArtifacts; -pub type JoltStageOpeningInputValue = crate::stages::common::StageOpeningInputValue; +pub type JoltStageChallengeVector = bolt_verifier_runtime::StageChallengeVector; +pub type JoltStageExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; +pub type JoltStageOpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; #[derive(Clone, Debug)] pub struct JoltEvaluationProof { From f56b939152b362ec272ea1906fbe342bc9ed145b Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 08:49:20 -0600 Subject: [PATCH 018/171] refactor(bolt): add typed verifier program executor --- crates/bolt/src/emit/rust/artifacts.rs | 90 ++-- crates/bolt/src/protocols/jolt/artifacts.rs | 460 ++++++++++++++++++- crates/bolt/tests/verifier_cleanup.rs | 46 +- crates/jolt-equivalence/src/bolt_oracle.rs | 1 + crates/jolt-verifier/src/lib.rs | 16 +- crates/jolt-verifier/src/verifier.rs | 472 +++++++++++++++++--- 6 files changed, 958 insertions(+), 127 deletions(-) diff --git a/crates/bolt/src/emit/rust/artifacts.rs b/crates/bolt/src/emit/rust/artifacts.rs index 1b9936fa77..857aa2bbfc 100644 --- a/crates/bolt/src/emit/rust/artifacts.rs +++ b/crates/bolt/src/emit/rust/artifacts.rs @@ -132,6 +132,7 @@ pub struct ProtocolVerifierApiExtension { pub error_conversions: String, pub after_default_verify: String, pub with_programs_body_intro: String, + pub verification_body_override: String, pub stage_verification_override: String, pub after_stage_verification: String, pub helper_items: String, @@ -847,51 +848,58 @@ fn generated_verifier_api( if let Some(extension) = extension { source.push_str(&extension.verifier.with_programs_body_intro); } - if let Some(prefix) = &config.instrumentation_prefix { - source.push_str(&format!( - " let _verify_span = tracing::info_span!(\"{prefix}.verify\").entered();\n" - )); - } - if let Some(commitment) = &commitment { - let verifier_fn = commitment - .with_program_verifier_fn - .as_deref() - .or(commitment.verifier_fn.as_deref()) - .unwrap_or("missing_commitment_verifier_function"); - let program_arg = if commitment.with_program_verifier_fn.is_some() - && commitment.program_type.is_some() - && commitment.program_const.is_some() - { - format!("programs.{}, ", commitment.field_name) - } else { - String::new() - }; - source.push_str(&format!( - " let {field} = {module}::{verifier_fn}({program_arg}&proof.commitments, transcript)?;\n", - field = commitment.field_name, - module = commitment.module_alias, - )); - } - if let Some(extension) = extension { - if !extension.verifier.stage_verification_override.is_empty() { - source.push_str(&extension.verifier.stage_verification_override); + let verification_body_override = extension + .map(|extension| extension.verifier.verification_body_override.as_str()) + .unwrap_or_default(); + if !verification_body_override.is_empty() { + source.push_str(verification_body_override); + } else { + if let Some(prefix) = &config.instrumentation_prefix { + source.push_str(&format!( + " let _verify_span = tracing::info_span!(\"{prefix}.verify\").entered();\n" + )); + } + if let Some(commitment) = &commitment { + let verifier_fn = commitment + .with_program_verifier_fn + .as_deref() + .or(commitment.verifier_fn.as_deref()) + .unwrap_or("missing_commitment_verifier_function"); + let program_arg = if commitment.with_program_verifier_fn.is_some() + && commitment.program_type.is_some() + && commitment.program_const.is_some() + { + format!("programs.{}, ", commitment.field_name) + } else { + String::new() + }; + source.push_str(&format!( + " let {field} = {module}::{verifier_fn}({program_arg}&proof.commitments, transcript)?;\n", + field = commitment.field_name, + module = commitment.module_alias, + )); + } + if let Some(extension) = extension { + if !extension.verifier.stage_verification_override.is_empty() { + source.push_str(&extension.verifier.stage_verification_override); + } else { + emit_verifier_stage_calls(&mut source, &stages); + } } else { emit_verifier_stage_calls(&mut source, &stages); } - } else { - emit_verifier_stage_calls(&mut source, &stages); - } - if let Some(extension) = extension { - source.push_str(&extension.verifier.after_stage_verification); - } - source.push_str(&format!("\n Ok({verification_artifacts_type} {{\n")); - if let Some(commitment) = &commitment { - source.push_str(&format!(" {},\n", commitment.field_name)); - } - for stage in &stages { - source.push_str(&format!(" {},\n", stage.field_name)); + if let Some(extension) = extension { + source.push_str(&extension.verifier.after_stage_verification); + } + source.push_str(&format!("\n Ok({verification_artifacts_type} {{\n")); + if let Some(commitment) = &commitment { + source.push_str(&format!(" {},\n", commitment.field_name)); + } + for stage in &stages { + source.push_str(&format!(" {},\n", stage.field_name)); + } + source.push_str(" })\n}\n\n"); } - source.push_str(" })\n}\n\n"); if let Some(extension) = extension { source.push_str(&extension.verifier.helper_items); diff --git a/crates/bolt/src/protocols/jolt/artifacts.rs b/crates/bolt/src/protocols/jolt/artifacts.rs index 7bff07f9d2..f7965abba4 100644 --- a/crates/bolt/src/protocols/jolt/artifacts.rs +++ b/crates/bolt/src/protocols/jolt/artifacts.rs @@ -327,12 +327,16 @@ pub use verifier::{ verify_jolt_prefix_with_programs, verify_jolt_through_stage5, verify_jolt_through_stage5_with_programs, verify_jolt_through_stage6, verify_jolt_through_stage6_with_programs, verify_jolt_through_stage7, - verify_jolt_through_stage7_with_programs, verify_jolt_with_programs, JoltEvaluationProof, - JoltEvaluationProofError, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData, - JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData, - JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, - JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, JoltVerificationArtifacts, - JoltVerifierInputs, JoltVerifierPrograms, JoltVerifierTarget, JoltVerifyError, + verify_jolt_through_stage7_with_programs, verify_jolt_with_programs, JoltEvaluationPolicy, + JoltEvaluationProof, JoltEvaluationProofError, JoltNamedEval, JoltProof, JoltProofSlot, + JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, + JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, + JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, + JoltVerificationArtifacts, JoltVerifierCheckpoint, JoltVerifierInputs, + JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepPlan, + JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, JOLT_TARGET_FULL, + JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6, JOLT_TARGET_THROUGH_STAGE7, + JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM, };" .to_owned() } @@ -370,17 +374,19 @@ fn jolt_evaluation_role_api_extension() -> ProtocolArtifactExtension { inputs_derive: Some("#[derive(Clone, Copy)]".to_owned()), input_fields: " pub evaluation_setup: Option<&'a DoryVerifierSetup>,\n".to_owned(), program_fields: - " pub stage8: &'static stage8_stage::Stage8EvaluationProgramPlan,\n".to_owned(), - default_program_fields: " stage8: &stage8_stage::STAGE8_PROGRAM,\n".to_owned(), - error_variants: " Evaluation(JoltEvaluationProofError),\n".to_owned(), - error_items: format!("{}{}", jolt_verifier_target_items(), "#[derive(Debug)]\npub enum JoltEvaluationProofError {\n MissingProof,\n MissingVerifierSetup,\n MissingStageEval { stage: &'static str, eval: &'static str },\n MissingStage7RaEval,\n MissingStage7EvaluationPoint,\n MissingCommitment { oracle: &'static str },\n InvalidPointLength {\n artifact: &'static str,\n expected: usize,\n actual: usize,\n },\n Opening(OpeningsError),\n}\n\n"), - error_conversions: "impl From for JoltVerifyError {\n fn from(error: JoltEvaluationProofError) -> Self {\n Self::Evaluation(error)\n }\n}\n\nimpl From for JoltEvaluationProofError {\n fn from(error: OpeningsError) -> Self {\n Self::Opening(error)\n }\n}\n\n".to_owned(), + " pub verifier: &'static JoltVerifierProgramPlan,\n pub stage8: &'static stage8_stage::Stage8EvaluationProgramPlan,\n".to_owned(), + default_program_fields: " verifier: &VERIFIER_PROGRAM,\n stage8: &stage8_stage::STAGE8_PROGRAM,\n".to_owned(), + error_variants: " Program(JoltVerifierProgramError),\n Evaluation(JoltEvaluationProofError),\n".to_owned(), + error_items: format!("{}{}", jolt_verifier_program_items(), "#[derive(Debug)]\npub enum JoltEvaluationProofError {\n MissingProof,\n MissingVerifierSetup,\n MissingStageEval { stage: &'static str, eval: &'static str },\n MissingStage7RaEval,\n MissingStage7EvaluationPoint,\n MissingCommitment { oracle: &'static str },\n InvalidPointLength {\n artifact: &'static str,\n expected: usize,\n actual: usize,\n },\n Opening(OpeningsError),\n}\n\n"), + error_conversions: "impl From for JoltVerifyError {\n fn from(error: JoltVerifierProgramError) -> Self {\n Self::Program(error)\n }\n}\n\nimpl From for JoltVerifyError {\n fn from(error: JoltEvaluationProofError) -> Self {\n Self::Evaluation(error)\n }\n}\n\nimpl From for JoltEvaluationProofError {\n fn from(error: OpeningsError) -> Self {\n Self::Opening(error)\n }\n}\n\n".to_owned(), after_default_verify: "pub fn verify_jolt_prefix>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, transcript: &mut T) -> Result { verify_jolt_prefix_with_programs(proof, inputs, default_verifier_programs(), transcript) }\n\npub fn verify_jolt_through_stage5>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, transcript: &mut T) -> Result { verify_jolt_through_stage5_with_programs(proof, inputs, default_verifier_programs(), transcript) }\n\npub fn verify_jolt_through_stage6>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, transcript: &mut T) -> Result { verify_jolt_through_stage6_with_programs(proof, inputs, default_verifier_programs(), transcript) }\n\npub fn verify_jolt_through_stage7>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, transcript: &mut T) -> Result { verify_jolt_through_stage7_with_programs(proof, inputs, default_verifier_programs(), transcript) }\n\n".to_owned(), - with_programs_body_intro: " verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::Full)\n}\n\npub fn verify_jolt_through_stage5_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage5) }\n\npub fn verify_jolt_through_stage6_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage6) }\n\npub fn verify_jolt_through_stage7_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage7) }\n\npub fn verify_jolt_prefix_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_through_stage7_with_programs(proof, inputs, programs, transcript) }\n\nfn verify_jolt_with_programs_inner>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T, target: JoltVerifierTarget) -> Result {\n".to_owned(), - stage_verification_override: jolt_verifier_stage_verification(), - after_stage_verification: jolt_verifier_evaluation_check(), + with_programs_body_intro: " verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_FULL)\n}\n\npub fn verify_jolt_through_stage5_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE5) }\n\npub fn verify_jolt_through_stage6_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE6) }\n\npub fn verify_jolt_through_stage7_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE7) }\n\npub fn verify_jolt_prefix_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_through_stage7_with_programs(proof, inputs, programs, transcript) }\n\nfn verify_jolt_with_programs_inner>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T, target: JoltVerifierTarget) -> Result {\n".to_owned(), + verification_body_override: jolt_verifier_execution_body(), + stage_verification_override: String::new(), + after_stage_verification: String::new(), helper_items: format!( - "{}{}", + "{}{}{}", + jolt_verifier_program_executor(), jolt_verifier_input_helpers("Jolt"), jolt_verifier_evaluation_helpers("Jolt", "Fr") ), @@ -388,16 +394,428 @@ fn jolt_evaluation_role_api_extension() -> ProtocolArtifactExtension { } } -fn jolt_verifier_target_items() -> String { - "#[derive(Clone, Copy, Debug, PartialEq, Eq)]\npub enum JoltVerifierTarget {\n ThroughStage5,\n ThroughStage6,\n ThroughStage7,\n Full,\n}\n\nimpl JoltVerifierTarget {\n fn verifies_stage6(self) -> bool { matches!(self, Self::ThroughStage6 | Self::ThroughStage7 | Self::Full) }\n fn verifies_stage7(self) -> bool { matches!(self, Self::ThroughStage7 | Self::Full) }\n fn verifies_evaluation(self) -> bool { matches!(self, Self::Full) }\n fn allows_optional_evaluation(self) -> bool { matches!(self, Self::ThroughStage7 | Self::Full) }\n}\n\n".to_owned() +fn jolt_verifier_program_items() -> String { + r"#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum JoltProofSlot { + Commitments, + Stage1Outer, + Stage2, + Stage3, + Stage4, + Stage5, + Stage6, + Stage7, + Evaluation, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum JoltVerifierStepPlan { + ReceiveCommitments { slot: JoltProofSlot }, + VerifySumcheckStage { slot: JoltProofSlot }, + VerifyPcsOpening { slot: JoltProofSlot }, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum JoltVerifierCheckpoint { + AfterStage5, + AfterStage6, + AfterStage7, + AfterEvaluation, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum JoltEvaluationPolicy { + Skip, + VerifyIfPresent, + Required, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct JoltVerifierTarget { + pub checkpoint: JoltVerifierCheckpoint, + pub evaluation: JoltEvaluationPolicy, +} + +pub const JOLT_TARGET_THROUGH_STAGE5: JoltVerifierTarget = JoltVerifierTarget { + checkpoint: JoltVerifierCheckpoint::AfterStage5, + evaluation: JoltEvaluationPolicy::Skip, +}; + +pub const JOLT_TARGET_THROUGH_STAGE6: JoltVerifierTarget = JoltVerifierTarget { + checkpoint: JoltVerifierCheckpoint::AfterStage6, + evaluation: JoltEvaluationPolicy::Skip, +}; + +pub const JOLT_TARGET_THROUGH_STAGE7: JoltVerifierTarget = JoltVerifierTarget { + checkpoint: JoltVerifierCheckpoint::AfterStage7, + evaluation: JoltEvaluationPolicy::VerifyIfPresent, +}; + +pub const JOLT_TARGET_FULL: JoltVerifierTarget = JoltVerifierTarget { + checkpoint: JoltVerifierCheckpoint::AfterEvaluation, + evaluation: JoltEvaluationPolicy::Required, +}; + +#[derive(Clone, Copy, Debug)] +pub struct JoltVerifierTargetPlan { + pub target: JoltVerifierTarget, + pub steps: &'static [JoltVerifierStepPlan], +} + +#[derive(Clone, Copy, Debug)] +pub struct JoltVerifierProgramPlan { + pub targets: &'static [JoltVerifierTargetPlan], +} + +pub const JOLT_VERIFY_THROUGH_STAGE5_STEPS: &[JoltVerifierStepPlan] = &[ + JoltVerifierStepPlan::ReceiveCommitments { + slot: JoltProofSlot::Commitments, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage1Outer, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage2, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage3, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage4, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage5, + }, +]; + +pub const JOLT_VERIFY_THROUGH_STAGE6_STEPS: &[JoltVerifierStepPlan] = &[ + JoltVerifierStepPlan::ReceiveCommitments { + slot: JoltProofSlot::Commitments, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage1Outer, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage2, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage3, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage4, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage5, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage6, + }, +]; + +pub const JOLT_VERIFY_THROUGH_STAGE7_STEPS: &[JoltVerifierStepPlan] = &[ + JoltVerifierStepPlan::ReceiveCommitments { + slot: JoltProofSlot::Commitments, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage1Outer, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage2, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage3, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage4, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage5, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage6, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage7, + }, + JoltVerifierStepPlan::VerifyPcsOpening { + slot: JoltProofSlot::Evaluation, + }, +]; + +pub const JOLT_VERIFY_FULL_STEPS: &[JoltVerifierStepPlan] = JOLT_VERIFY_THROUGH_STAGE7_STEPS; + +pub const JOLT_VERIFIER_TARGETS: &[JoltVerifierTargetPlan] = &[ + JoltVerifierTargetPlan { + target: JOLT_TARGET_THROUGH_STAGE5, + steps: JOLT_VERIFY_THROUGH_STAGE5_STEPS, + }, + JoltVerifierTargetPlan { + target: JOLT_TARGET_THROUGH_STAGE6, + steps: JOLT_VERIFY_THROUGH_STAGE6_STEPS, + }, + JoltVerifierTargetPlan { + target: JOLT_TARGET_THROUGH_STAGE7, + steps: JOLT_VERIFY_THROUGH_STAGE7_STEPS, + }, + JoltVerifierTargetPlan { + target: JOLT_TARGET_FULL, + steps: JOLT_VERIFY_FULL_STEPS, + }, +]; + +pub const VERIFIER_PROGRAM: JoltVerifierProgramPlan = JoltVerifierProgramPlan { + targets: JOLT_VERIFIER_TARGETS, +}; + +#[derive(Debug)] +pub enum JoltVerifierProgramError { + MissingTarget { target: JoltVerifierTarget }, + MissingArtifact { slot: JoltProofSlot }, + UnsupportedStep { + step: JoltVerifierStepPlan, + reason: &'static str, + }, } -fn jolt_verifier_stage_verification() -> String { - " let stage1_outer = stage1_outer_stage::verify_stage1_outer_with_program(programs.stage1_outer, &proof.stage1_outer, transcript)?;\n let stage2 = stage2_stage::verify_stage2_with_program(programs.stage2, &proof.stage2, inputs.stage2_openings, inputs.stage2_ram, transcript)?;\n let stage3 = stage3_stage::verify_stage3_with_program(programs.stage3, &proof.stage3, inputs.stage3_openings, transcript)?;\n let stage4 = stage4_stage::verify_stage4_with_program(programs.stage4, &proof.stage4, inputs.stage4_openings, transcript)?;\n let stage5 = stage5_stage::verify_stage5_with_program(programs.stage5, &proof.stage5, inputs.stage5_openings, transcript)?;\n let stage6 = if target.verifies_stage6() {\n stage6_stage::verify_stage6_with_program(programs.stage6, &proof.stage6, inputs.stage6_openings, inputs.stage6_data, transcript)?\n } else {\n stage6_stage::Stage6ExecutionArtifacts::default()\n };\n let stage7 = if target.verifies_stage7() {\n stage7_stage::verify_stage7_with_program(programs.stage7, &proof.stage7, inputs.stage7_openings, transcript)?\n } else {\n stage7_stage::Stage7ExecutionArtifacts::default()\n };\n".to_owned() +" + .to_owned() } -fn jolt_verifier_evaluation_check() -> String { - " if target.allows_optional_evaluation() {\n match (&proof.evaluation, inputs.evaluation_setup) {\n (Some(evaluation), Some(setup)) => {\n verify_jolt_evaluation_proof(\n programs.stage8,\n evaluation,\n &commitment,\n &proof.stage6,\n &proof.stage7,\n inputs.stage7_openings,\n setup,\n transcript,\n )?;\n }\n (Some(_), None) => return Err(JoltEvaluationProofError::MissingVerifierSetup.into()),\n (None, Some(_)) => return Err(JoltEvaluationProofError::MissingProof.into()),\n (None, None) if target.verifies_evaluation() => return Err(JoltEvaluationProofError::MissingProof.into()),\n (None, None) => {}\n }\n }\n".to_owned() +fn jolt_verifier_execution_body() -> String { + " let _verify_span = tracing::info_span!(\"bolt.verify\").entered();\n execute_jolt_verifier_program(proof, inputs, programs, transcript, target)\n}\n\n".to_owned() +} + +fn jolt_verifier_program_executor() -> String { + r#"fn execute_jolt_verifier_program( + proof: &JoltProof, + inputs: JoltVerifierInputs<'_>, + programs: JoltVerifierPrograms, + transcript: &mut T, + target: JoltVerifierTarget, +) -> Result +where + T: Transcript, +{ + let target_plan = programs + .verifier + .targets + .iter() + .find(|plan| plan.target == target) + .ok_or(JoltVerifierProgramError::MissingTarget { target })?; + let mut artifacts = JoltArtifactStore::default(); + for step in target_plan.steps { + execute_jolt_verifier_step( + *step, + proof, + inputs, + programs, + transcript, + target_plan, + &mut artifacts, + )?; + } + artifacts.into_public_artifacts().map_err(JoltVerifyError::from) +} + +fn execute_jolt_verifier_step( + step: JoltVerifierStepPlan, + proof: &JoltProof, + inputs: JoltVerifierInputs<'_>, + programs: JoltVerifierPrograms, + transcript: &mut T, + target_plan: &JoltVerifierTargetPlan, + artifacts: &mut JoltArtifactStore, +) -> Result<(), JoltVerifyError> +where + T: Transcript, +{ + match step { + JoltVerifierStepPlan::ReceiveCommitments { + slot: JoltProofSlot::Commitments, + } => { + artifacts.commitment = Some(commitment_stage::verify_commitment_phase_with_program( + programs.commitment, + &proof.commitments, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage1Outer, + } => { + artifacts.stage1_outer = Some(stage1_outer_stage::verify_stage1_outer_with_program( + programs.stage1_outer, + &proof.stage1_outer, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage2, + } => { + artifacts.stage2 = Some(stage2_stage::verify_stage2_with_program( + programs.stage2, + &proof.stage2, + inputs.stage2_openings, + inputs.stage2_ram, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage3, + } => { + artifacts.stage3 = Some(stage3_stage::verify_stage3_with_program( + programs.stage3, + &proof.stage3, + inputs.stage3_openings, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage4, + } => { + artifacts.stage4 = Some(stage4_stage::verify_stage4_with_program( + programs.stage4, + &proof.stage4, + inputs.stage4_openings, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage5, + } => { + artifacts.stage5 = Some(stage5_stage::verify_stage5_with_program( + programs.stage5, + &proof.stage5, + inputs.stage5_openings, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage6, + } => { + artifacts.stage6 = Some(stage6_stage::verify_stage6_with_program( + programs.stage6, + &proof.stage6, + inputs.stage6_openings, + inputs.stage6_data, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage7, + } => { + artifacts.stage7 = Some(stage7_stage::verify_stage7_with_program( + programs.stage7, + &proof.stage7, + inputs.stage7_openings, + transcript, + )?); + } + JoltVerifierStepPlan::VerifyPcsOpening { + slot: JoltProofSlot::Evaluation, + } => { + verify_jolt_evaluation_step( + target_plan.target.evaluation, + proof, + inputs, + programs, + transcript, + artifacts, + )?; + } + step => { + return Err(JoltVerifierProgramError::UnsupportedStep { + step, + reason: "step kind and proof slot are incompatible", + } + .into()); + } + } + Ok(()) +} + +fn verify_jolt_evaluation_step( + evaluation: JoltEvaluationPolicy, + proof: &JoltProof, + inputs: JoltVerifierInputs<'_>, + programs: JoltVerifierPrograms, + transcript: &mut T, + artifacts: &JoltArtifactStore, +) -> Result<(), JoltVerifyError> +where + T: Transcript, +{ + if evaluation == JoltEvaluationPolicy::Skip { + return Ok(()); + } + match (&proof.evaluation, inputs.evaluation_setup) { + (Some(evaluation_proof), Some(setup)) => { + verify_jolt_evaluation_proof( + programs.stage8, + evaluation_proof, + artifacts.commitment()?, + &proof.stage6, + &proof.stage7, + inputs.stage7_openings, + setup, + transcript, + )?; + } + (Some(_), None) => return Err(JoltEvaluationProofError::MissingVerifierSetup.into()), + (None, Some(_)) => return Err(JoltEvaluationProofError::MissingProof.into()), + (None, None) if evaluation == JoltEvaluationPolicy::Required => { + return Err(JoltEvaluationProofError::MissingProof.into()); + } + (None, None) => {} + } + Ok(()) +} + +#[derive(Default)] +struct JoltArtifactStore { + commitment: Option, + stage1_outer: Option>, + stage2: Option>, + stage3: Option>, + stage4: Option>, + stage5: Option>, + stage6: Option>, + stage7: Option>, +} + +impl JoltArtifactStore { + fn commitment( + &self, + ) -> Result<&commitment_stage::CommitmentArtifacts, JoltVerifierProgramError> { + self.commitment + .as_ref() + .ok_or(JoltVerifierProgramError::MissingArtifact { + slot: JoltProofSlot::Commitments, + }) + } + + fn into_public_artifacts(self) -> Result { + Ok(JoltVerificationArtifacts { + commitment: required_artifact(self.commitment, JoltProofSlot::Commitments)?, + stage1_outer: required_artifact(self.stage1_outer, JoltProofSlot::Stage1Outer)?, + stage2: required_artifact(self.stage2, JoltProofSlot::Stage2)?, + stage3: required_artifact(self.stage3, JoltProofSlot::Stage3)?, + stage4: required_artifact(self.stage4, JoltProofSlot::Stage4)?, + stage5: required_artifact(self.stage5, JoltProofSlot::Stage5)?, + stage6: self.stage6.unwrap_or_default(), + stage7: self.stage7.unwrap_or_default(), + }) + } +} + +fn required_artifact( + artifact: Option, + slot: JoltProofSlot, +) -> Result { + artifact.ok_or(JoltVerifierProgramError::MissingArtifact { slot }) +} + +"# + .to_owned() } fn jolt_verifier_input_helpers(prefix: &str) -> String { diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 6144530a73..ff530dd5e5 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -6,9 +6,12 @@ use std::path::{Path, PathBuf}; -const GENERATED_VERIFIER_TARGET_LOC: usize = 6_100; +/// S2.5 intentionally moves top-level verifier-program data into +/// `verifier.rs`. Later value-graph slices should ratchet this back down as +/// more stage-local math becomes typed data instead of Rust helpers. +const GENERATED_VERIFIER_TARGET_LOC: usize = 6_500; const GENERATED_VERIFIER_STRETCH_LOC: usize = 3_000; -const VERIFIER_RS_TARGET_LOC: usize = 500; +const VERIFIER_RS_TARGET_LOC: usize = 850; const VERIFIER_RS_STRETCH_LOC: usize = 350; const STAGE6_STAGE7_TARGET_LOC: usize = 3_000; @@ -335,6 +338,45 @@ fn checked_in_generated_verifier_respects_boundary_hygiene() { } } +#[test] +fn checked_in_generated_verifier_uses_typed_top_level_program() { + let verifier_rs = workspace_root().join("crates/jolt-verifier/src/verifier.rs"); + if !verifier_rs.exists() { + return; + } + let source = std::fs::read_to_string(&verifier_rs).expect("read verifier.rs"); + for pattern in [ + "pub const VERIFIER_PROGRAM", + "pub enum JoltProofSlot", + "pub enum JoltVerifierStepPlan", + "JoltVerifierStepPlan::ReceiveCommitments", + "JoltVerifierStepPlan::VerifySumcheckStage", + "JoltVerifierStepPlan::VerifyPcsOpening", + "fn execute_jolt_verifier_program", + "fn execute_jolt_verifier_step", + "struct JoltArtifactStore", + ] { + assert!( + source.contains(pattern), + "generated verifier.rs is missing typed top-level verifier-program pattern `{pattern}`" + ); + } + for stale_pattern in [ + "JoltVerifierTarget::ThroughStage", + "fn verifies_stage6", + "fn verifies_stage7", + "fn verifies_evaluation", + "fn allows_optional_evaluation", + "target.verifies_stage", + "target.allows_optional_evaluation", + ] { + assert!( + !source.contains(stale_pattern), + "generated verifier.rs still contains stale target-control-flow pattern `{stale_pattern}`" + ); + } +} + #[test] fn verifier_cpu_fixtures_are_kernel_free() { let fixtures = workspace_root().join("crates/bolt/tests/fixtures"); diff --git a/crates/jolt-equivalence/src/bolt_oracle.rs b/crates/jolt-equivalence/src/bolt_oracle.rs index 22441dcd2b..718ffe9764 100644 --- a/crates/jolt-equivalence/src/bolt_oracle.rs +++ b/crates/jolt-equivalence/src/bolt_oracle.rs @@ -139,6 +139,7 @@ pub fn assert_bolt_full_real_trace_self_parity( stage5: generated_stage5_verifier_plan, stage6: generated_stage6_verifier_plan, stage7: generated_stage7_verifier_plan, + verifier: &jolt_verifier::VERIFIER_PROGRAM, stage8: generated_stage8_verifier_plan, }; let r1cs_key = fixture.r1cs_key(); diff --git a/crates/jolt-verifier/src/lib.rs b/crates/jolt-verifier/src/lib.rs index c9dfdffc26..6807a7c0dd 100644 --- a/crates/jolt-verifier/src/lib.rs +++ b/crates/jolt-verifier/src/lib.rs @@ -17,12 +17,16 @@ pub use verifier::{ verify_jolt_prefix_with_programs, verify_jolt_through_stage5, verify_jolt_through_stage5_with_programs, verify_jolt_through_stage6, verify_jolt_through_stage6_with_programs, verify_jolt_through_stage7, - verify_jolt_through_stage7_with_programs, verify_jolt_with_programs, JoltEvaluationProof, - JoltEvaluationProofError, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData, - JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData, - JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, - JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, JoltVerificationArtifacts, - JoltVerifierInputs, JoltVerifierPrograms, JoltVerifierTarget, JoltVerifyError, + verify_jolt_through_stage7_with_programs, verify_jolt_with_programs, JoltEvaluationPolicy, + JoltEvaluationProof, JoltEvaluationProofError, JoltNamedEval, JoltProof, JoltProofSlot, + JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, + JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, + JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, + JoltVerificationArtifacts, JoltVerifierCheckpoint, JoltVerifierInputs, + JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepPlan, + JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, JOLT_TARGET_FULL, + JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6, JOLT_TARGET_THROUGH_STAGE7, + JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM, }; pub const TRANSCRIPT_LABEL: &[u8] = b"Jolt"; diff --git a/crates/jolt-verifier/src/verifier.rs b/crates/jolt-verifier/src/verifier.rs index 5b997c13c6..dd1ec4f19d 100644 --- a/crates/jolt-verifier/src/verifier.rs +++ b/crates/jolt-verifier/src/verifier.rs @@ -60,6 +60,7 @@ pub struct JoltVerifierPrograms { pub stage5: &'static stage5_stage::Stage5VerifierProgramPlan, pub stage6: &'static stage6_stage::Stage6VerifierProgramPlan, pub stage7: &'static stage7_stage::Stage7VerifierProgramPlan, + pub verifier: &'static JoltVerifierProgramPlan, pub stage8: &'static stage8_stage::Stage8EvaluationProgramPlan, } @@ -73,6 +74,7 @@ pub fn default_verifier_programs() -> JoltVerifierPrograms { stage5: &stage5_stage::STAGE5_PROGRAM, stage6: &stage6_stage::STAGE6_PROGRAM, stage7: &stage7_stage::STAGE7_PROGRAM, + verifier: &VERIFIER_PROGRAM, stage8: &stage8_stage::STAGE8_PROGRAM, } } @@ -99,22 +101,190 @@ pub enum JoltVerifyError { Stage5(stage5_stage::VerifyStage5Error), Stage6(stage6_stage::VerifyStage6Error), Stage7(stage7_stage::VerifyStage7Error), + Program(JoltVerifierProgramError), Evaluation(JoltEvaluationProofError), } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum JoltVerifierTarget { - ThroughStage5, - ThroughStage6, - ThroughStage7, - Full, +pub enum JoltProofSlot { + Commitments, + Stage1Outer, + Stage2, + Stage3, + Stage4, + Stage5, + Stage6, + Stage7, + Evaluation, } -impl JoltVerifierTarget { - fn verifies_stage6(self) -> bool { matches!(self, Self::ThroughStage6 | Self::ThroughStage7 | Self::Full) } - fn verifies_stage7(self) -> bool { matches!(self, Self::ThroughStage7 | Self::Full) } - fn verifies_evaluation(self) -> bool { matches!(self, Self::Full) } - fn allows_optional_evaluation(self) -> bool { matches!(self, Self::ThroughStage7 | Self::Full) } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum JoltVerifierStepPlan { + ReceiveCommitments { slot: JoltProofSlot }, + VerifySumcheckStage { slot: JoltProofSlot }, + VerifyPcsOpening { slot: JoltProofSlot }, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum JoltVerifierCheckpoint { + AfterStage5, + AfterStage6, + AfterStage7, + AfterEvaluation, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum JoltEvaluationPolicy { + Skip, + VerifyIfPresent, + Required, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct JoltVerifierTarget { + pub checkpoint: JoltVerifierCheckpoint, + pub evaluation: JoltEvaluationPolicy, +} + +pub const JOLT_TARGET_THROUGH_STAGE5: JoltVerifierTarget = JoltVerifierTarget { + checkpoint: JoltVerifierCheckpoint::AfterStage5, + evaluation: JoltEvaluationPolicy::Skip, +}; + +pub const JOLT_TARGET_THROUGH_STAGE6: JoltVerifierTarget = JoltVerifierTarget { + checkpoint: JoltVerifierCheckpoint::AfterStage6, + evaluation: JoltEvaluationPolicy::Skip, +}; + +pub const JOLT_TARGET_THROUGH_STAGE7: JoltVerifierTarget = JoltVerifierTarget { + checkpoint: JoltVerifierCheckpoint::AfterStage7, + evaluation: JoltEvaluationPolicy::VerifyIfPresent, +}; + +pub const JOLT_TARGET_FULL: JoltVerifierTarget = JoltVerifierTarget { + checkpoint: JoltVerifierCheckpoint::AfterEvaluation, + evaluation: JoltEvaluationPolicy::Required, +}; + +#[derive(Clone, Copy, Debug)] +pub struct JoltVerifierTargetPlan { + pub target: JoltVerifierTarget, + pub steps: &'static [JoltVerifierStepPlan], +} + +#[derive(Clone, Copy, Debug)] +pub struct JoltVerifierProgramPlan { + pub targets: &'static [JoltVerifierTargetPlan], +} + +pub const JOLT_VERIFY_THROUGH_STAGE5_STEPS: &[JoltVerifierStepPlan] = &[ + JoltVerifierStepPlan::ReceiveCommitments { + slot: JoltProofSlot::Commitments, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage1Outer, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage2, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage3, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage4, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage5, + }, +]; + +pub const JOLT_VERIFY_THROUGH_STAGE6_STEPS: &[JoltVerifierStepPlan] = &[ + JoltVerifierStepPlan::ReceiveCommitments { + slot: JoltProofSlot::Commitments, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage1Outer, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage2, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage3, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage4, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage5, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage6, + }, +]; + +pub const JOLT_VERIFY_THROUGH_STAGE7_STEPS: &[JoltVerifierStepPlan] = &[ + JoltVerifierStepPlan::ReceiveCommitments { + slot: JoltProofSlot::Commitments, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage1Outer, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage2, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage3, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage4, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage5, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage6, + }, + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage7, + }, + JoltVerifierStepPlan::VerifyPcsOpening { + slot: JoltProofSlot::Evaluation, + }, +]; + +pub const JOLT_VERIFY_FULL_STEPS: &[JoltVerifierStepPlan] = JOLT_VERIFY_THROUGH_STAGE7_STEPS; + +pub const JOLT_VERIFIER_TARGETS: &[JoltVerifierTargetPlan] = &[ + JoltVerifierTargetPlan { + target: JOLT_TARGET_THROUGH_STAGE5, + steps: JOLT_VERIFY_THROUGH_STAGE5_STEPS, + }, + JoltVerifierTargetPlan { + target: JOLT_TARGET_THROUGH_STAGE6, + steps: JOLT_VERIFY_THROUGH_STAGE6_STEPS, + }, + JoltVerifierTargetPlan { + target: JOLT_TARGET_THROUGH_STAGE7, + steps: JOLT_VERIFY_THROUGH_STAGE7_STEPS, + }, + JoltVerifierTargetPlan { + target: JOLT_TARGET_FULL, + steps: JOLT_VERIFY_FULL_STEPS, + }, +]; + +pub const VERIFIER_PROGRAM: JoltVerifierProgramPlan = JoltVerifierProgramPlan { + targets: JOLT_VERIFIER_TARGETS, +}; + +#[derive(Debug)] +pub enum JoltVerifierProgramError { + MissingTarget { target: JoltVerifierTarget }, + MissingArtifact { slot: JoltProofSlot }, + UnsupportedStep { + step: JoltVerifierStepPlan, + reason: &'static str, + }, } #[derive(Debug)] @@ -152,6 +322,12 @@ define_jolt_verify_error_from!(stage5_stage, VerifyStage5Error, Stage5); define_jolt_verify_error_from!(stage6_stage, VerifyStage6Error, Stage6); define_jolt_verify_error_from!(stage7_stage, VerifyStage7Error, Stage7); +impl From for JoltVerifyError { + fn from(error: JoltVerifierProgramError) -> Self { + Self::Program(error) + } +} + impl From for JoltVerifyError { fn from(error: JoltEvaluationProofError) -> Self { Self::Evaluation(error) @@ -177,66 +353,248 @@ pub fn verify_jolt_through_stage6>(proof: &JoltPro pub fn verify_jolt_through_stage7>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, transcript: &mut T) -> Result { verify_jolt_through_stage7_with_programs(proof, inputs, default_verifier_programs(), transcript) } pub fn verify_jolt_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { - verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::Full) + verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_FULL) } -pub fn verify_jolt_through_stage5_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage5) } +pub fn verify_jolt_through_stage5_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE5) } -pub fn verify_jolt_through_stage6_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage6) } +pub fn verify_jolt_through_stage6_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE6) } -pub fn verify_jolt_through_stage7_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JoltVerifierTarget::ThroughStage7) } +pub fn verify_jolt_through_stage7_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_with_programs_inner(proof, inputs, programs, transcript, JOLT_TARGET_THROUGH_STAGE7) } pub fn verify_jolt_prefix_with_programs>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T) -> Result { verify_jolt_through_stage7_with_programs(proof, inputs, programs, transcript) } fn verify_jolt_with_programs_inner>(proof: &JoltProof, inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T, target: JoltVerifierTarget) -> Result { let _verify_span = tracing::info_span!("bolt.verify").entered(); - let commitment = commitment_stage::verify_commitment_phase_with_program(programs.commitment, &proof.commitments, transcript)?; - let stage1_outer = stage1_outer_stage::verify_stage1_outer_with_program(programs.stage1_outer, &proof.stage1_outer, transcript)?; - let stage2 = stage2_stage::verify_stage2_with_program(programs.stage2, &proof.stage2, inputs.stage2_openings, inputs.stage2_ram, transcript)?; - let stage3 = stage3_stage::verify_stage3_with_program(programs.stage3, &proof.stage3, inputs.stage3_openings, transcript)?; - let stage4 = stage4_stage::verify_stage4_with_program(programs.stage4, &proof.stage4, inputs.stage4_openings, transcript)?; - let stage5 = stage5_stage::verify_stage5_with_program(programs.stage5, &proof.stage5, inputs.stage5_openings, transcript)?; - let stage6 = if target.verifies_stage6() { - stage6_stage::verify_stage6_with_program(programs.stage6, &proof.stage6, inputs.stage6_openings, inputs.stage6_data, transcript)? - } else { - stage6_stage::Stage6ExecutionArtifacts::default() - }; - let stage7 = if target.verifies_stage7() { - stage7_stage::verify_stage7_with_program(programs.stage7, &proof.stage7, inputs.stage7_openings, transcript)? - } else { - stage7_stage::Stage7ExecutionArtifacts::default() - }; - if target.allows_optional_evaluation() { - match (&proof.evaluation, inputs.evaluation_setup) { - (Some(evaluation), Some(setup)) => { - verify_jolt_evaluation_proof( - programs.stage8, - evaluation, - &commitment, - &proof.stage6, - &proof.stage7, - inputs.stage7_openings, - setup, - transcript, - )?; + execute_jolt_verifier_program(proof, inputs, programs, transcript, target) +} + +fn execute_jolt_verifier_program( + proof: &JoltProof, + inputs: JoltVerifierInputs<'_>, + programs: JoltVerifierPrograms, + transcript: &mut T, + target: JoltVerifierTarget, +) -> Result +where + T: Transcript, +{ + let target_plan = programs + .verifier + .targets + .iter() + .find(|plan| plan.target == target) + .ok_or(JoltVerifierProgramError::MissingTarget { target })?; + let mut artifacts = JoltArtifactStore::default(); + for step in target_plan.steps { + execute_jolt_verifier_step( + *step, + proof, + inputs, + programs, + transcript, + target_plan, + &mut artifacts, + )?; + } + artifacts.into_public_artifacts().map_err(JoltVerifyError::from) +} + +fn execute_jolt_verifier_step( + step: JoltVerifierStepPlan, + proof: &JoltProof, + inputs: JoltVerifierInputs<'_>, + programs: JoltVerifierPrograms, + transcript: &mut T, + target_plan: &JoltVerifierTargetPlan, + artifacts: &mut JoltArtifactStore, +) -> Result<(), JoltVerifyError> +where + T: Transcript, +{ + match step { + JoltVerifierStepPlan::ReceiveCommitments { + slot: JoltProofSlot::Commitments, + } => { + artifacts.commitment = Some(commitment_stage::verify_commitment_phase_with_program( + programs.commitment, + &proof.commitments, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage1Outer, + } => { + artifacts.stage1_outer = Some(stage1_outer_stage::verify_stage1_outer_with_program( + programs.stage1_outer, + &proof.stage1_outer, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage2, + } => { + artifacts.stage2 = Some(stage2_stage::verify_stage2_with_program( + programs.stage2, + &proof.stage2, + inputs.stage2_openings, + inputs.stage2_ram, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage3, + } => { + artifacts.stage3 = Some(stage3_stage::verify_stage3_with_program( + programs.stage3, + &proof.stage3, + inputs.stage3_openings, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage4, + } => { + artifacts.stage4 = Some(stage4_stage::verify_stage4_with_program( + programs.stage4, + &proof.stage4, + inputs.stage4_openings, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage5, + } => { + artifacts.stage5 = Some(stage5_stage::verify_stage5_with_program( + programs.stage5, + &proof.stage5, + inputs.stage5_openings, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage6, + } => { + artifacts.stage6 = Some(stage6_stage::verify_stage6_with_program( + programs.stage6, + &proof.stage6, + inputs.stage6_openings, + inputs.stage6_data, + transcript, + )?); + } + JoltVerifierStepPlan::VerifySumcheckStage { + slot: JoltProofSlot::Stage7, + } => { + artifacts.stage7 = Some(stage7_stage::verify_stage7_with_program( + programs.stage7, + &proof.stage7, + inputs.stage7_openings, + transcript, + )?); + } + JoltVerifierStepPlan::VerifyPcsOpening { + slot: JoltProofSlot::Evaluation, + } => { + verify_jolt_evaluation_step( + target_plan.target.evaluation, + proof, + inputs, + programs, + transcript, + artifacts, + )?; + } + step => { + return Err(JoltVerifierProgramError::UnsupportedStep { + step, + reason: "step kind and proof slot are incompatible", } - (Some(_), None) => return Err(JoltEvaluationProofError::MissingVerifierSetup.into()), - (None, Some(_)) => return Err(JoltEvaluationProofError::MissingProof.into()), - (None, None) if target.verifies_evaluation() => return Err(JoltEvaluationProofError::MissingProof.into()), - (None, None) => {} + .into()); } } + Ok(()) +} - Ok(JoltVerificationArtifacts { - commitment, - stage1_outer, - stage2, - stage3, - stage4, - stage5, - stage6, - stage7, - }) +fn verify_jolt_evaluation_step( + evaluation: JoltEvaluationPolicy, + proof: &JoltProof, + inputs: JoltVerifierInputs<'_>, + programs: JoltVerifierPrograms, + transcript: &mut T, + artifacts: &JoltArtifactStore, +) -> Result<(), JoltVerifyError> +where + T: Transcript, +{ + if evaluation == JoltEvaluationPolicy::Skip { + return Ok(()); + } + match (&proof.evaluation, inputs.evaluation_setup) { + (Some(evaluation_proof), Some(setup)) => { + verify_jolt_evaluation_proof( + programs.stage8, + evaluation_proof, + artifacts.commitment()?, + &proof.stage6, + &proof.stage7, + inputs.stage7_openings, + setup, + transcript, + )?; + } + (Some(_), None) => return Err(JoltEvaluationProofError::MissingVerifierSetup.into()), + (None, Some(_)) => return Err(JoltEvaluationProofError::MissingProof.into()), + (None, None) if evaluation == JoltEvaluationPolicy::Required => { + return Err(JoltEvaluationProofError::MissingProof.into()); + } + (None, None) => {} + } + Ok(()) +} + +#[derive(Default)] +struct JoltArtifactStore { + commitment: Option, + stage1_outer: Option>, + stage2: Option>, + stage3: Option>, + stage4: Option>, + stage5: Option>, + stage6: Option>, + stage7: Option>, +} + +impl JoltArtifactStore { + fn commitment( + &self, + ) -> Result<&commitment_stage::CommitmentArtifacts, JoltVerifierProgramError> { + self.commitment + .as_ref() + .ok_or(JoltVerifierProgramError::MissingArtifact { + slot: JoltProofSlot::Commitments, + }) + } + + fn into_public_artifacts(self) -> Result { + Ok(JoltVerificationArtifacts { + commitment: required_artifact(self.commitment, JoltProofSlot::Commitments)?, + stage1_outer: required_artifact(self.stage1_outer, JoltProofSlot::Stage1Outer)?, + stage2: required_artifact(self.stage2, JoltProofSlot::Stage2)?, + stage3: required_artifact(self.stage3, JoltProofSlot::Stage3)?, + stage4: required_artifact(self.stage4, JoltProofSlot::Stage4)?, + stage5: required_artifact(self.stage5, JoltProofSlot::Stage5)?, + stage6: self.stage6.unwrap_or_default(), + stage7: self.stage7.unwrap_or_default(), + }) + } +} + +fn required_artifact( + artifact: Option, + slot: JoltProofSlot, +) -> Result { + artifact.ok_or(JoltVerifierProgramError::MissingArtifact { slot }) } impl<'a> JoltVerifierInputs<'a> { From 0f40f5e96e9576fb05060265deb514bf6d747d67 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 09:31:30 -0600 Subject: [PATCH 019/171] refactor(bolt): move verifier program model into runtime --- crates/bolt-verifier-runtime/src/lib.rs | 104 ++++++++++ crates/bolt/src/protocols/jolt/artifacts.rs | 202 ++++++-------------- crates/bolt/tests/verifier_cleanup.rs | 20 +- crates/jolt-verifier/src/lib.rs | 8 +- crates/jolt-verifier/src/verifier.rs | 196 +++++-------------- 5 files changed, 230 insertions(+), 300 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 18f98925f8..9dd06813f6 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -62,6 +62,110 @@ pub trait ProtocolRelation: Copy + Eq + fmt::Debug + 'static {} impl ProtocolRelation for T {} +pub trait VerifierProgramSlot: Copy + Eq + fmt::Debug + 'static {} + +impl VerifierProgramSlot for T {} + +pub trait VerifierProgramCheckpoint: Copy + Eq + fmt::Debug + 'static {} + +impl VerifierProgramCheckpoint for T {} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum VerifierProgramStepKind { + ReceiveCommitments, + VerifySumcheckStage, + VerifyPcsOpening, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct VerifierProgramStepPlan { + pub kind: VerifierProgramStepKind, + pub slot: S, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum VerifierEvaluationPolicy { + Skip, + VerifyIfPresent, + Required, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct VerifierTarget { + pub checkpoint: C, + pub evaluation: VerifierEvaluationPolicy, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct VerifierTargetPlan { + pub target: VerifierTarget, + pub step_count: usize, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct VerifierProgramPlan { + pub steps: &'static [VerifierProgramStepPlan], + pub targets: &'static [VerifierTargetPlan], +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum VerifierProgramError { + MissingTarget { + target: T, + }, + InvalidStepCount { + target: T, + step_count: usize, + total_steps: usize, + }, + MissingArtifact { + slot: S, + }, + UnsupportedStep { + step: VerifierProgramStepPlan, + reason: &'static str, + }, +} + +impl VerifierProgramPlan { + pub fn steps_for( + &self, + target: VerifierTarget, + ) -> Result<&'static [VerifierProgramStepPlan], VerifierProgramError>> + { + let target_plan = self + .targets + .iter() + .find(|plan| plan.target == target) + .ok_or(VerifierProgramError::MissingTarget { target })?; + let step_count = target_plan.step_count; + if step_count > self.steps.len() { + return Err(VerifierProgramError::InvalidStepCount { + target, + step_count, + total_steps: self.steps.len(), + }); + } + Ok(&self.steps[..step_count]) + } +} + +pub fn execute_verifier_program( + program: &VerifierProgramPlan, + target: VerifierTarget, + mut execute_step: impl FnMut(VerifierProgramStepPlan) -> Result<(), E>, +) -> Result<(), E> +where + S: VerifierProgramSlot, + C: VerifierProgramCheckpoint, + E: From>>, +{ + for step in program.steps_for(target).map_err(E::from)? { + execute_step(*step)?; + } + Ok(()) +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum TranscriptSqueezeKind { ChallengeScalar, diff --git a/crates/bolt/src/protocols/jolt/artifacts.rs b/crates/bolt/src/protocols/jolt/artifacts.rs index f7965abba4..cf2adeeab8 100644 --- a/crates/bolt/src/protocols/jolt/artifacts.rs +++ b/crates/bolt/src/protocols/jolt/artifacts.rs @@ -334,9 +334,9 @@ pub use verifier::{ JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, JoltVerificationArtifacts, JoltVerifierCheckpoint, JoltVerifierInputs, JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepPlan, - JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, JOLT_TARGET_FULL, - JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6, JOLT_TARGET_THROUGH_STAGE7, - JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM, + JoltVerifierStepKind, JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, + JOLT_TARGET_FULL, JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6, + JOLT_TARGET_THROUGH_STAGE7, JOLT_VERIFIER_STEPS, JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM, };" .to_owned() } @@ -408,12 +408,8 @@ pub enum JoltProofSlot { Evaluation, } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum JoltVerifierStepPlan { - ReceiveCommitments { slot: JoltProofSlot }, - VerifySumcheckStage { slot: JoltProofSlot }, - VerifyPcsOpening { slot: JoltProofSlot }, -} +pub type JoltVerifierStepKind = bolt_verifier_runtime::VerifierProgramStepKind; +pub type JoltVerifierStepPlan = bolt_verifier_runtime::VerifierProgramStepPlan; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum JoltVerifierCheckpoint { @@ -423,18 +419,13 @@ pub enum JoltVerifierCheckpoint { AfterEvaluation, } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum JoltEvaluationPolicy { - Skip, - VerifyIfPresent, - Required, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct JoltVerifierTarget { - pub checkpoint: JoltVerifierCheckpoint, - pub evaluation: JoltEvaluationPolicy, -} +pub type JoltEvaluationPolicy = bolt_verifier_runtime::VerifierEvaluationPolicy; +pub type JoltVerifierTarget = bolt_verifier_runtime::VerifierTarget; +pub type JoltVerifierTargetPlan = bolt_verifier_runtime::VerifierTargetPlan; +pub type JoltVerifierProgramPlan = + bolt_verifier_runtime::VerifierProgramPlan; +pub type JoltVerifierProgramError = + bolt_verifier_runtime::VerifierProgramError; pub const JOLT_TARGET_THROUGH_STAGE5: JoltVerifierTarget = JoltVerifierTarget { checkpoint: JoltVerifierCheckpoint::AfterStage5, @@ -456,127 +447,69 @@ pub const JOLT_TARGET_FULL: JoltVerifierTarget = JoltVerifierTarget { evaluation: JoltEvaluationPolicy::Required, }; -#[derive(Clone, Copy, Debug)] -pub struct JoltVerifierTargetPlan { - pub target: JoltVerifierTarget, - pub steps: &'static [JoltVerifierStepPlan], -} - -#[derive(Clone, Copy, Debug)] -pub struct JoltVerifierProgramPlan { - pub targets: &'static [JoltVerifierTargetPlan], -} - -pub const JOLT_VERIFY_THROUGH_STAGE5_STEPS: &[JoltVerifierStepPlan] = &[ - JoltVerifierStepPlan::ReceiveCommitments { - slot: JoltProofSlot::Commitments, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage1Outer, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage2, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage3, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage4, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage5, - }, -]; - -pub const JOLT_VERIFY_THROUGH_STAGE6_STEPS: &[JoltVerifierStepPlan] = &[ - JoltVerifierStepPlan::ReceiveCommitments { - slot: JoltProofSlot::Commitments, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage1Outer, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage2, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage3, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage4, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage5, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage6, - }, -]; - -pub const JOLT_VERIFY_THROUGH_STAGE7_STEPS: &[JoltVerifierStepPlan] = &[ - JoltVerifierStepPlan::ReceiveCommitments { +pub const JOLT_VERIFIER_STEPS: &[JoltVerifierStepPlan] = &[ + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::ReceiveCommitments, slot: JoltProofSlot::Commitments, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage1Outer, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage2, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage3, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage4, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage5, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage6, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage7, }, - JoltVerifierStepPlan::VerifyPcsOpening { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifyPcsOpening, slot: JoltProofSlot::Evaluation, }, ]; -pub const JOLT_VERIFY_FULL_STEPS: &[JoltVerifierStepPlan] = JOLT_VERIFY_THROUGH_STAGE7_STEPS; - pub const JOLT_VERIFIER_TARGETS: &[JoltVerifierTargetPlan] = &[ JoltVerifierTargetPlan { target: JOLT_TARGET_THROUGH_STAGE5, - steps: JOLT_VERIFY_THROUGH_STAGE5_STEPS, + step_count: 6, }, JoltVerifierTargetPlan { target: JOLT_TARGET_THROUGH_STAGE6, - steps: JOLT_VERIFY_THROUGH_STAGE6_STEPS, + step_count: 7, }, JoltVerifierTargetPlan { target: JOLT_TARGET_THROUGH_STAGE7, - steps: JOLT_VERIFY_THROUGH_STAGE7_STEPS, + step_count: 9, }, JoltVerifierTargetPlan { target: JOLT_TARGET_FULL, - steps: JOLT_VERIFY_FULL_STEPS, + step_count: 9, }, ]; pub const VERIFIER_PROGRAM: JoltVerifierProgramPlan = JoltVerifierProgramPlan { + steps: JOLT_VERIFIER_STEPS, targets: JOLT_VERIFIER_TARGETS, }; -#[derive(Debug)] -pub enum JoltVerifierProgramError { - MissingTarget { target: JoltVerifierTarget }, - MissingArtifact { slot: JoltProofSlot }, - UnsupportedStep { - step: JoltVerifierStepPlan, - reason: &'static str, - }, -} - " .to_owned() } @@ -596,24 +529,18 @@ fn jolt_verifier_program_executor() -> String { where T: Transcript, { - let target_plan = programs - .verifier - .targets - .iter() - .find(|plan| plan.target == target) - .ok_or(JoltVerifierProgramError::MissingTarget { target })?; let mut artifacts = JoltArtifactStore::default(); - for step in target_plan.steps { + bolt_verifier_runtime::execute_verifier_program(programs.verifier, target, |step| { execute_jolt_verifier_step( - *step, + step, proof, inputs, programs, transcript, - target_plan, + target.evaluation, &mut artifacts, - )?; - } + ) + })?; artifacts.into_public_artifacts().map_err(JoltVerifyError::from) } @@ -623,34 +550,29 @@ fn execute_jolt_verifier_step( inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T, - target_plan: &JoltVerifierTargetPlan, + evaluation: JoltEvaluationPolicy, artifacts: &mut JoltArtifactStore, ) -> Result<(), JoltVerifyError> where T: Transcript, { - match step { - JoltVerifierStepPlan::ReceiveCommitments { - slot: JoltProofSlot::Commitments, - } => { + let step_plan = step; + match (step.kind, step.slot) { + (JoltVerifierStepKind::ReceiveCommitments, JoltProofSlot::Commitments) => { artifacts.commitment = Some(commitment_stage::verify_commitment_phase_with_program( programs.commitment, &proof.commitments, transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage1Outer, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage1Outer) => { artifacts.stage1_outer = Some(stage1_outer_stage::verify_stage1_outer_with_program( programs.stage1_outer, &proof.stage1_outer, transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage2, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage2) => { artifacts.stage2 = Some(stage2_stage::verify_stage2_with_program( programs.stage2, &proof.stage2, @@ -659,9 +581,7 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage3, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage3) => { artifacts.stage3 = Some(stage3_stage::verify_stage3_with_program( programs.stage3, &proof.stage3, @@ -669,9 +589,7 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage4, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage4) => { artifacts.stage4 = Some(stage4_stage::verify_stage4_with_program( programs.stage4, &proof.stage4, @@ -679,9 +597,7 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage5, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage5) => { artifacts.stage5 = Some(stage5_stage::verify_stage5_with_program( programs.stage5, &proof.stage5, @@ -689,9 +605,7 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage6, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage6) => { artifacts.stage6 = Some(stage6_stage::verify_stage6_with_program( programs.stage6, &proof.stage6, @@ -700,9 +614,7 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage7, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage7) => { artifacts.stage7 = Some(stage7_stage::verify_stage7_with_program( programs.stage7, &proof.stage7, @@ -710,11 +622,9 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifyPcsOpening { - slot: JoltProofSlot::Evaluation, - } => { + (JoltVerifierStepKind::VerifyPcsOpening, JoltProofSlot::Evaluation) => { verify_jolt_evaluation_step( - target_plan.target.evaluation, + evaluation, proof, inputs, programs, @@ -722,9 +632,9 @@ where artifacts, )?; } - step => { + _ => { return Err(JoltVerifierProgramError::UnsupportedStep { - step, + step: step_plan, reason: "step kind and proof slot are incompatible", } .into()); diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index ff530dd5e5..29ae290299 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -6,9 +6,9 @@ use std::path::{Path, PathBuf}; -/// S2.5 intentionally moves top-level verifier-program data into -/// `verifier.rs`. Later value-graph slices should ratchet this back down as -/// more stage-local math becomes typed data instead of Rust helpers. +/// S2.5 keeps only Jolt-specific verifier-program data in generated +/// `verifier.rs`; reusable program shape and dispatch live in +/// `crates/bolt-verifier-runtime`. const GENERATED_VERIFIER_TARGET_LOC: usize = 6_500; const GENERATED_VERIFIER_STRETCH_LOC: usize = 3_000; const VERIFIER_RS_TARGET_LOC: usize = 850; @@ -347,11 +347,17 @@ fn checked_in_generated_verifier_uses_typed_top_level_program() { let source = std::fs::read_to_string(&verifier_rs).expect("read verifier.rs"); for pattern in [ "pub const VERIFIER_PROGRAM", + "pub const JOLT_VERIFIER_STEPS", "pub enum JoltProofSlot", - "pub enum JoltVerifierStepPlan", - "JoltVerifierStepPlan::ReceiveCommitments", - "JoltVerifierStepPlan::VerifySumcheckStage", - "JoltVerifierStepPlan::VerifyPcsOpening", + "pub enum JoltVerifierCheckpoint", + "pub type JoltVerifierStepKind = bolt_verifier_runtime::VerifierProgramStepKind", + "pub type JoltVerifierStepPlan = bolt_verifier_runtime::VerifierProgramStepPlan", + "pub type JoltVerifierTargetPlan = bolt_verifier_runtime::VerifierTargetPlan", + "JoltVerifierStepKind::ReceiveCommitments", + "JoltVerifierStepKind::VerifySumcheckStage", + "JoltVerifierStepKind::VerifyPcsOpening", + "step_count:", + "bolt_verifier_runtime::execute_verifier_program", "fn execute_jolt_verifier_program", "fn execute_jolt_verifier_step", "struct JoltArtifactStore", diff --git a/crates/jolt-verifier/src/lib.rs b/crates/jolt-verifier/src/lib.rs index 6807a7c0dd..90f218a585 100644 --- a/crates/jolt-verifier/src/lib.rs +++ b/crates/jolt-verifier/src/lib.rs @@ -23,10 +23,10 @@ pub use verifier::{ JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, JoltVerificationArtifacts, JoltVerifierCheckpoint, JoltVerifierInputs, - JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepPlan, - JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, JOLT_TARGET_FULL, - JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6, JOLT_TARGET_THROUGH_STAGE7, - JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM, + JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepKind, + JoltVerifierStepPlan, JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, + JOLT_TARGET_FULL, JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6, + JOLT_TARGET_THROUGH_STAGE7, JOLT_VERIFIER_STEPS, JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM, }; pub const TRANSCRIPT_LABEL: &[u8] = b"Jolt"; diff --git a/crates/jolt-verifier/src/verifier.rs b/crates/jolt-verifier/src/verifier.rs index dd1ec4f19d..dcebe535d9 100644 --- a/crates/jolt-verifier/src/verifier.rs +++ b/crates/jolt-verifier/src/verifier.rs @@ -118,12 +118,8 @@ pub enum JoltProofSlot { Evaluation, } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum JoltVerifierStepPlan { - ReceiveCommitments { slot: JoltProofSlot }, - VerifySumcheckStage { slot: JoltProofSlot }, - VerifyPcsOpening { slot: JoltProofSlot }, -} +pub type JoltVerifierStepKind = bolt_verifier_runtime::VerifierProgramStepKind; +pub type JoltVerifierStepPlan = bolt_verifier_runtime::VerifierProgramStepPlan; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum JoltVerifierCheckpoint { @@ -133,18 +129,13 @@ pub enum JoltVerifierCheckpoint { AfterEvaluation, } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum JoltEvaluationPolicy { - Skip, - VerifyIfPresent, - Required, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct JoltVerifierTarget { - pub checkpoint: JoltVerifierCheckpoint, - pub evaluation: JoltEvaluationPolicy, -} +pub type JoltEvaluationPolicy = bolt_verifier_runtime::VerifierEvaluationPolicy; +pub type JoltVerifierTarget = bolt_verifier_runtime::VerifierTarget; +pub type JoltVerifierTargetPlan = bolt_verifier_runtime::VerifierTargetPlan; +pub type JoltVerifierProgramPlan = + bolt_verifier_runtime::VerifierProgramPlan; +pub type JoltVerifierProgramError = + bolt_verifier_runtime::VerifierProgramError; pub const JOLT_TARGET_THROUGH_STAGE5: JoltVerifierTarget = JoltVerifierTarget { checkpoint: JoltVerifierCheckpoint::AfterStage5, @@ -166,127 +157,69 @@ pub const JOLT_TARGET_FULL: JoltVerifierTarget = JoltVerifierTarget { evaluation: JoltEvaluationPolicy::Required, }; -#[derive(Clone, Copy, Debug)] -pub struct JoltVerifierTargetPlan { - pub target: JoltVerifierTarget, - pub steps: &'static [JoltVerifierStepPlan], -} - -#[derive(Clone, Copy, Debug)] -pub struct JoltVerifierProgramPlan { - pub targets: &'static [JoltVerifierTargetPlan], -} - -pub const JOLT_VERIFY_THROUGH_STAGE5_STEPS: &[JoltVerifierStepPlan] = &[ - JoltVerifierStepPlan::ReceiveCommitments { +pub const JOLT_VERIFIER_STEPS: &[JoltVerifierStepPlan] = &[ + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::ReceiveCommitments, slot: JoltProofSlot::Commitments, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage1Outer, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage2, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage3, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage4, }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage5, }, -]; - -pub const JOLT_VERIFY_THROUGH_STAGE6_STEPS: &[JoltVerifierStepPlan] = &[ - JoltVerifierStepPlan::ReceiveCommitments { - slot: JoltProofSlot::Commitments, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage1Outer, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage2, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage3, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage4, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage5, - }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage6, }, -]; - -pub const JOLT_VERIFY_THROUGH_STAGE7_STEPS: &[JoltVerifierStepPlan] = &[ - JoltVerifierStepPlan::ReceiveCommitments { - slot: JoltProofSlot::Commitments, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage1Outer, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage2, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage3, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage4, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage5, - }, - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage6, - }, - JoltVerifierStepPlan::VerifySumcheckStage { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifySumcheckStage, slot: JoltProofSlot::Stage7, }, - JoltVerifierStepPlan::VerifyPcsOpening { + JoltVerifierStepPlan { + kind: JoltVerifierStepKind::VerifyPcsOpening, slot: JoltProofSlot::Evaluation, }, ]; -pub const JOLT_VERIFY_FULL_STEPS: &[JoltVerifierStepPlan] = JOLT_VERIFY_THROUGH_STAGE7_STEPS; - pub const JOLT_VERIFIER_TARGETS: &[JoltVerifierTargetPlan] = &[ JoltVerifierTargetPlan { target: JOLT_TARGET_THROUGH_STAGE5, - steps: JOLT_VERIFY_THROUGH_STAGE5_STEPS, + step_count: 6, }, JoltVerifierTargetPlan { target: JOLT_TARGET_THROUGH_STAGE6, - steps: JOLT_VERIFY_THROUGH_STAGE6_STEPS, + step_count: 7, }, JoltVerifierTargetPlan { target: JOLT_TARGET_THROUGH_STAGE7, - steps: JOLT_VERIFY_THROUGH_STAGE7_STEPS, + step_count: 9, }, JoltVerifierTargetPlan { target: JOLT_TARGET_FULL, - steps: JOLT_VERIFY_FULL_STEPS, + step_count: 9, }, ]; pub const VERIFIER_PROGRAM: JoltVerifierProgramPlan = JoltVerifierProgramPlan { + steps: JOLT_VERIFIER_STEPS, targets: JOLT_VERIFIER_TARGETS, }; -#[derive(Debug)] -pub enum JoltVerifierProgramError { - MissingTarget { target: JoltVerifierTarget }, - MissingArtifact { slot: JoltProofSlot }, - UnsupportedStep { - step: JoltVerifierStepPlan, - reason: &'static str, - }, -} - #[derive(Debug)] pub enum JoltEvaluationProofError { MissingProof, @@ -379,24 +312,18 @@ fn execute_jolt_verifier_program( where T: Transcript, { - let target_plan = programs - .verifier - .targets - .iter() - .find(|plan| plan.target == target) - .ok_or(JoltVerifierProgramError::MissingTarget { target })?; let mut artifacts = JoltArtifactStore::default(); - for step in target_plan.steps { + bolt_verifier_runtime::execute_verifier_program(programs.verifier, target, |step| { execute_jolt_verifier_step( - *step, + step, proof, inputs, programs, transcript, - target_plan, + target.evaluation, &mut artifacts, - )?; - } + ) + })?; artifacts.into_public_artifacts().map_err(JoltVerifyError::from) } @@ -406,34 +333,29 @@ fn execute_jolt_verifier_step( inputs: JoltVerifierInputs<'_>, programs: JoltVerifierPrograms, transcript: &mut T, - target_plan: &JoltVerifierTargetPlan, + evaluation: JoltEvaluationPolicy, artifacts: &mut JoltArtifactStore, ) -> Result<(), JoltVerifyError> where T: Transcript, { - match step { - JoltVerifierStepPlan::ReceiveCommitments { - slot: JoltProofSlot::Commitments, - } => { + let step_plan = step; + match (step.kind, step.slot) { + (JoltVerifierStepKind::ReceiveCommitments, JoltProofSlot::Commitments) => { artifacts.commitment = Some(commitment_stage::verify_commitment_phase_with_program( programs.commitment, &proof.commitments, transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage1Outer, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage1Outer) => { artifacts.stage1_outer = Some(stage1_outer_stage::verify_stage1_outer_with_program( programs.stage1_outer, &proof.stage1_outer, transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage2, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage2) => { artifacts.stage2 = Some(stage2_stage::verify_stage2_with_program( programs.stage2, &proof.stage2, @@ -442,9 +364,7 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage3, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage3) => { artifacts.stage3 = Some(stage3_stage::verify_stage3_with_program( programs.stage3, &proof.stage3, @@ -452,9 +372,7 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage4, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage4) => { artifacts.stage4 = Some(stage4_stage::verify_stage4_with_program( programs.stage4, &proof.stage4, @@ -462,9 +380,7 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage5, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage5) => { artifacts.stage5 = Some(stage5_stage::verify_stage5_with_program( programs.stage5, &proof.stage5, @@ -472,9 +388,7 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage6, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage6) => { artifacts.stage6 = Some(stage6_stage::verify_stage6_with_program( programs.stage6, &proof.stage6, @@ -483,9 +397,7 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifySumcheckStage { - slot: JoltProofSlot::Stage7, - } => { + (JoltVerifierStepKind::VerifySumcheckStage, JoltProofSlot::Stage7) => { artifacts.stage7 = Some(stage7_stage::verify_stage7_with_program( programs.stage7, &proof.stage7, @@ -493,11 +405,9 @@ where transcript, )?); } - JoltVerifierStepPlan::VerifyPcsOpening { - slot: JoltProofSlot::Evaluation, - } => { + (JoltVerifierStepKind::VerifyPcsOpening, JoltProofSlot::Evaluation) => { verify_jolt_evaluation_step( - target_plan.target.evaluation, + evaluation, proof, inputs, programs, @@ -505,9 +415,9 @@ where artifacts, )?; } - step => { + _ => { return Err(JoltVerifierProgramError::UnsupportedStep { - step, + step: step_plan, reason: "step kind and proof slot are incompatible", } .into()); From e53de5014f9c994b08575b3e8992df1b1cc063fd Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 10:01:53 -0600 Subject: [PATCH 020/171] refactor(bolt): lift stage3 output claims into plans Move Stage 3 verifier output-claim formulas from emitted helper functions into runtime-interpreted typed output-claim plans. Preserve proof serialization and update equivalence adapters plus generated artifacts. --- crates/bolt-verifier-runtime/src/lib.rs | 73 ++- .../src/protocols/jolt/emit/rust/stage3.rs | 566 +++++++++++++++--- crates/jolt-equivalence/src/plan_adapters.rs | 61 ++ .../src/plan_adapters/generated_stage3.rs | 2 + crates/jolt-verifier/src/lib.rs | 4 +- crates/jolt-verifier/src/stages/stage3.rs | 154 ++--- 6 files changed, 676 insertions(+), 184 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 9dd06813f6..885a334d41 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -7,7 +7,7 @@ use std::fmt; use std::marker::PhantomData; use jolt_field::{Field, Fr, MulPow2}; -use jolt_poly::lagrange::lagrange_evals; +use jolt_poly::{lagrange::lagrange_evals, EqPlusOnePolynomial, EqPolynomial}; use jolt_sumcheck::{ CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier, }; @@ -311,6 +311,34 @@ pub struct SumcheckInstanceResultPlan { pub degree: usize, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SumcheckOutputPointOrder { + AsIs, + Reverse, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SumcheckOutputValueKind { + EqMle, + EqPlusOne, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct SumcheckOutputValuePlan { + pub symbol: &'static str, + pub kind: SumcheckOutputValueKind, + pub point_order: SumcheckOutputPointOrder, + pub local_point_source: &'static str, + pub opening_point_source: &'static str, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct SumcheckOutputClaimPlan { + pub relation: R, + pub local_values: &'static [SumcheckOutputValuePlan], + pub claim_value: &'static str, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct SumcheckEvalPlan { pub symbol: &'static str, @@ -439,6 +467,7 @@ pub struct StageVerifierProgramPlan { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], + pub output_claims: &'static [SumcheckOutputClaimPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], pub opening_claims: &'static [OpeningClaimPlan], @@ -1079,6 +1108,48 @@ pub fn eval_by_name( .ok_or(RuntimePlanError::MissingValue { symbol: name }) } +pub fn evaluate_sumcheck_output_claim( + plan: &SumcheckOutputClaimPlan, + field_exprs: &[FieldExprPlan], + store: &ValueStore, + instance_symbol: &'static str, + evals: &[StageNamedEval], + local_point: &[Fr], +) -> Result { + let mut scratch = store.clone(); + for eval in evals { + scratch.insert_scalar(eval.name, eval.value); + } + for local_value in plan.local_values { + if local_value.local_point_source != instance_symbol { + return Err(RuntimePlanError::InvalidProof { + driver: instance_symbol, + reason: "sumcheck output value source mismatch", + }); + } + let opening_point = scratch.point_or(local_value.opening_point_source, |symbol| { + RuntimePlanError::MissingValue { symbol } + })?; + let ordered_point = match local_value.point_order { + SumcheckOutputPointOrder::AsIs => local_point.to_vec(), + SumcheckOutputPointOrder::Reverse => reverse_slice(local_point), + }; + let value = match local_value.kind { + SumcheckOutputValueKind::EqMle => { + EqPolynomial::::mle(&ordered_point, opening_point) + } + SumcheckOutputValueKind::EqPlusOne => { + EqPlusOnePolynomial::::new(opening_point.to_vec()).evaluate(&ordered_point) + } + }; + scratch.insert_scalar(local_value.symbol, value); + } + scratch.evaluate_available_field_exprs(field_exprs, evaluate_field_expr)?; + scratch.scalar_or(plan.claim_value, |symbol| RuntimePlanError::MissingValue { + symbol, + }) +} + pub fn indexed_evals_by_prefix( evals: &[StageNamedEval], prefix: &'static str, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index cf3e14a67f..7651769023 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -23,6 +23,7 @@ pub struct Stage3CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, + pub output_claims: Vec, pub point_slices: Vec, pub point_concats: Vec, pub opening_claims: Vec, @@ -145,6 +146,22 @@ pub struct Stage3SumcheckInstanceResultPlan { pub degree: usize, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage3SumcheckOutputValuePlan { + pub symbol: String, + pub kind: String, + pub point_order: String, + pub local_point_source: String, + pub opening_point_source: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage3SumcheckOutputClaimPlan { + pub relation: String, + pub local_values: Vec, + pub claim_value: String, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage3SumcheckEvalPlan { pub symbol: String, @@ -217,6 +234,294 @@ pub fn emit_stage3_rust(module: &BoltModule<'_, Cpu>) -> Result Stage3FieldExprPlan { + Stage3FieldExprPlan { + symbol: symbol.to_owned(), + kind: "op".to_owned(), + formula: formula.to_owned(), + operand_names: operands + .iter() + .map(|operand| (*operand).to_owned()) + .collect(), + operands: operands + .iter() + .map(|operand| (*operand).to_owned()) + .collect(), + } +} + +fn stage3_output_value( + symbol: &str, + kind: &str, + local_point_source: &str, + opening_point_source: &str, +) -> Stage3SumcheckOutputValuePlan { + Stage3SumcheckOutputValuePlan { + symbol: symbol.to_owned(), + kind: kind.to_owned(), + point_order: "reverse".to_owned(), + local_point_source: local_point_source.to_owned(), + opening_point_source: opening_point_source.to_owned(), + } +} + +fn stage3_output_claim( + relation: &str, + local_values: Vec, + claim_value: &str, +) -> Stage3SumcheckOutputClaimPlan { + Stage3SumcheckOutputClaimPlan { + relation: relation.to_owned(), + local_values, + claim_value: claim_value.to_owned(), + } +} + +fn stage3_verifier_output_field_exprs() -> Vec { + vec![ + stage3_field_expr( + "stage3.spartan_shift.output.term.PC", + "field.mul", + &["stage3.spartan_shift.gamma", "stage3.spartan_shift.eval.PC"], + ), + stage3_field_expr( + "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", + "field.mul", + &[ + "stage3.spartan_shift.gamma2", + "stage3.spartan_shift.eval.OpFlagVirtualInstruction", + ], + ), + stage3_field_expr( + "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", + "field.mul", + &[ + "stage3.spartan_shift.gamma3", + "stage3.spartan_shift.eval.OpFlagIsFirstInSequence", + ], + ), + stage3_field_expr( + "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", + "field.sub", + &[ + "stage3.field.one", + "stage3.spartan_shift.eval.InstructionFlagIsNoop", + ], + ), + stage3_field_expr( + "stage3.spartan_shift.output.partial.PC", + "field.add", + &[ + "stage3.spartan_shift.eval.UnexpandedPC", + "stage3.spartan_shift.output.term.PC", + ], + ), + stage3_field_expr( + "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", + "field.add", + &[ + "stage3.spartan_shift.output.partial.PC", + "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", + ], + ), + stage3_field_expr( + "stage3.spartan_shift.output.weighted_outer", + "field.add", + &[ + "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", + "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", + ], + ), + stage3_field_expr( + "stage3.spartan_shift.output.outer", + "field.mul", + &[ + "stage3.spartan_shift.output.eq.NextPC", + "stage3.spartan_shift.output.weighted_outer", + ], + ), + stage3_field_expr( + "stage3.spartan_shift.output.noop_product", + "field.mul", + &[ + "stage3.spartan_shift.output.eq.NextIsNoop", + "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", + ], + ), + stage3_field_expr( + "stage3.spartan_shift.output.noop_term", + "field.mul", + &[ + "stage3.spartan_shift.gamma4", + "stage3.spartan_shift.output.noop_product", + ], + ), + stage3_field_expr( + "stage3.spartan_shift.output.claim_expr", + "field.add", + &[ + "stage3.spartan_shift.output.outer", + "stage3.spartan_shift.output.noop_term", + ], + ), + stage3_field_expr( + "stage3.instruction_input.output.left.term.Rs1Value", + "field.mul", + &[ + "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value", + "stage3.instruction_input.eval.Rs1Value", + ], + ), + stage3_field_expr( + "stage3.instruction_input.output.left.term.PC", + "field.mul", + &[ + "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC", + "stage3.instruction_input.eval.UnexpandedPC", + ], + ), + stage3_field_expr( + "stage3.instruction_input.output.left", + "field.add", + &[ + "stage3.instruction_input.output.left.term.Rs1Value", + "stage3.instruction_input.output.left.term.PC", + ], + ), + stage3_field_expr( + "stage3.instruction_input.output.right.term.Rs2Value", + "field.mul", + &[ + "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value", + "stage3.instruction_input.eval.Rs2Value", + ], + ), + stage3_field_expr( + "stage3.instruction_input.output.right.term.Imm", + "field.mul", + &[ + "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", + "stage3.instruction_input.eval.Imm", + ], + ), + stage3_field_expr( + "stage3.instruction_input.output.right", + "field.add", + &[ + "stage3.instruction_input.output.right.term.Rs2Value", + "stage3.instruction_input.output.right.term.Imm", + ], + ), + stage3_field_expr( + "stage3.instruction_input.output.left_weighted", + "field.mul", + &[ + "stage3.instruction_input.gamma", + "stage3.instruction_input.output.left", + ], + ), + stage3_field_expr( + "stage3.instruction_input.output.weighted_inputs", + "field.add", + &[ + "stage3.instruction_input.output.right", + "stage3.instruction_input.output.left_weighted", + ], + ), + stage3_field_expr( + "stage3.instruction_input.output.claim_expr", + "field.mul", + &[ + "stage3.instruction_input.output.eq.LeftInstructionInput", + "stage3.instruction_input.output.weighted_inputs", + ], + ), + stage3_field_expr( + "stage3.registers.output.term.Rs1Value", + "field.mul", + &[ + "stage3.registers.gamma", + "stage3.registers_claim_reduction.eval.Rs1Value", + ], + ), + stage3_field_expr( + "stage3.registers.output.term.Rs2Value", + "field.mul", + &[ + "stage3.registers.gamma2", + "stage3.registers_claim_reduction.eval.Rs2Value", + ], + ), + stage3_field_expr( + "stage3.registers.output.partial.RdWriteValueRs1Value", + "field.add", + &[ + "stage3.registers_claim_reduction.eval.RdWriteValue", + "stage3.registers.output.term.Rs1Value", + ], + ), + stage3_field_expr( + "stage3.registers.output.weighted_register_values", + "field.add", + &[ + "stage3.registers.output.partial.RdWriteValueRs1Value", + "stage3.registers.output.term.Rs2Value", + ], + ), + stage3_field_expr( + "stage3.registers.output.claim_expr", + "field.mul", + &[ + "stage3.registers.output.eq.RdWriteValue", + "stage3.registers.output.weighted_register_values", + ], + ), + ] +} + +fn stage3_verifier_output_claims() -> Vec { + vec![ + stage3_output_claim( + "jolt.stage3.spartan_shift", + vec![ + stage3_output_value( + "stage3.spartan_shift.output.eq.NextPC", + "eq_plus_one", + "stage3.spartan_shift.instance", + "stage3.input.stage1.NextPC", + ), + stage3_output_value( + "stage3.spartan_shift.output.eq.NextIsNoop", + "eq_plus_one", + "stage3.spartan_shift.instance", + "stage3.input.stage2.product_virtual.NextIsNoop", + ), + ], + "stage3.spartan_shift.output.claim_expr", + ), + stage3_output_claim( + "jolt.stage3.instruction_input", + vec![stage3_output_value( + "stage3.instruction_input.output.eq.LeftInstructionInput", + "eq_mle", + "stage3.instruction_input.instance", + "stage3.input.stage2.product_virtual.LeftInstructionInput", + )], + "stage3.instruction_input.output.claim_expr", + ), + stage3_output_claim( + "jolt.stage3.registers_claim_reduction", + vec![stage3_output_value( + "stage3.registers.output.eq.RdWriteValue", + "eq_mle", + "stage3.registers_claim_reduction.instance", + "stage3.input.stage1.RdWriteValue", + )], + "stage3.registers.output.claim_expr", + ), + ] +} + impl Stage3CpuProgram { fn from_module(module: &BoltModule<'_, Cpu>) -> Result { let mut params = None; @@ -496,11 +801,21 @@ impl Stage3CpuProgram { } } + let role = module + .role() + .ok_or_else(|| EmitError::new("missing cpu party role"))?; + if role == Role::Verifier { + field_exprs.extend(stage3_verifier_output_field_exprs()); + } + let output_claims = if role == Role::Verifier { + stage3_verifier_output_claims() + } else { + Vec::new() + }; + Ok(Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, - role: module - .role() - .ok_or_else(|| EmitError::new("missing cpu party role"))?, + role, steps, transcript_squeezes, opening_inputs, @@ -512,6 +827,7 @@ impl Stage3CpuProgram { drivers, instance_results, evals, + output_claims, point_slices, point_concats, opening_claims, @@ -534,6 +850,9 @@ impl Stage3CpuProgram { } Role::Verifier => self.verify_verifier_driver_bindings()?, } + if self.role == Role::Verifier { + self.verify_output_claims()?; + } self.verify_opening_flow() } @@ -603,6 +922,23 @@ impl Stage3CpuProgram { )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); + values.extend(symbols(self.output_claims.iter().flat_map(|claim| { + claim.local_values.iter().map(|value| &value.symbol) + }))); + values + } + + fn point_value_symbols(&self) -> BTreeSet { + let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); + values.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + values.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); values } @@ -779,6 +1115,57 @@ impl Stage3CpuProgram { Ok(()) } + fn verify_output_claims(&self) -> Result<(), EmitError> { + let relations = symbols( + self.instance_results + .iter() + .map(|instance| &instance.relation), + ); + let field_values = self.field_value_symbols(); + let point_values = self.point_value_symbols(); + for claim in &self.output_claims { + if !relations.contains(&claim.relation) { + return Err(EmitError::new(format!( + "stage3 output claim references missing relation @{}", + claim.relation + ))); + } + if !field_values.contains(&claim.claim_value) { + return Err(EmitError::new(format!( + "stage3 output claim for @{} uses missing claim value @{}", + claim.relation, claim.claim_value + ))); + } + for local_value in &claim.local_values { + if !point_values.contains(&local_value.local_point_source) { + return Err(EmitError::new(format!( + "stage3 output value @{} references missing local point @{}", + local_value.symbol, local_value.local_point_source + ))); + } + if !point_values.contains(&local_value.opening_point_source) { + return Err(EmitError::new(format!( + "stage3 output value @{} references missing opening point @{}", + local_value.symbol, local_value.opening_point_source + ))); + } + if !matches!(local_value.kind.as_str(), "eq_mle" | "eq_plus_one") { + return Err(EmitError::new(format!( + "stage3 output value @{} has unsupported kind `{}`", + local_value.symbol, local_value.kind + ))); + } + if !matches!(local_value.point_order.as_str(), "as_is" | "reverse") { + return Err(EmitError::new(format!( + "stage3 output value @{} has unsupported point order `{}`", + local_value.symbol, local_value.point_order + ))); + } + } + } + Ok(()) + } + fn verify_opening_flow(&self) -> Result<(), EmitError> { let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); point_sources.extend(symbols( @@ -954,9 +1341,8 @@ impl Stage3CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ + "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ use jolt_field::{Field, Fr};\n\ - use jolt_poly::{EqPlusOnePolynomial, EqPolynomial};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, Transcript};" } @@ -974,6 +1360,8 @@ pub type Stage3VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgram pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage3SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage3SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage3SumcheckOutputValuePlan = bolt_verifier_runtime::SumcheckOutputValuePlan; pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind; pub use bolt_verifier_runtime::{ @@ -988,6 +1376,8 @@ pub use bolt_verifier_runtime::{ ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, + SumcheckOutputPointOrder as Stage3SumcheckOutputPointOrder, + SumcheckOutputValueKind as Stage3SumcheckOutputValueKind, TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, }; @@ -1046,6 +1436,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_verifier_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); + source.push_str(&self.emit_verifier_output_claim_constants()?); source.push_str( "pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan {\n\ \x20 params: STAGE3_PARAMS,\n\ @@ -1059,6 +1450,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); \x20 drivers: STAGE3_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE3_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE3_SUMCHECK_EVALS,\n\ + \x20 output_claims: STAGE3_SUMCHECK_OUTPUT_CLAIMS,\n\ \x20 point_slices: STAGE3_POINT_SLICES,\n\ \x20 point_concats: STAGE3_POINT_CONCATS,\n\ \x20 opening_claims: STAGE3_OPENING_CLAIMS,\n\ @@ -1535,6 +1927,48 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); format!("pub const STAGE3_SUMCHECK_EVALS: &[Stage3SumcheckEvalPlan] = &[\n{evals}\n];\n\n") } + fn emit_verifier_output_claim_constants(&self) -> Result { + let mut source = String::new(); + let mut claims = Vec::new(); + for (index, claim) in self.output_claims.iter().enumerate() { + let values_name = format!("STAGE3_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES"); + let values = claim + .local_values + .iter() + .map(|value| { + Ok(format!( + " Stage3SumcheckOutputValuePlan {{ symbol: {}, kind: {}, point_order: {}, local_point_source: {}, opening_point_source: {} }},", + rust_str(&value.symbol), + stage3_output_value_kind_expr(&value.kind)?, + stage3_output_point_order_expr(&value.point_order)?, + rust_str(&value.local_point_source), + rust_str(&value.opening_point_source) + )) + }) + .collect::, EmitError>>()? + .join("\n"); + push_format( + &mut source, + format_args!( + "pub const {values_name}: &[Stage3SumcheckOutputValuePlan] = &[\n{values}\n];\n\n" + ), + ); + claims.push(format!( + " Stage3SumcheckOutputClaimPlan {{ relation: {}, local_values: {values_name}, claim_value: {} }},", + super::plan_tokens::role_relation_kind_expr("Stage3", &self.role, &claim.relation)?, + rust_str(&claim.claim_value) + )); + } + let claims = claims.join("\n"); + push_format( + &mut source, + format_args!( + "pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[\n{claims}\n];\n\n" + ), + ); + Ok(source) + } + fn emit_point_slice_constants(&self) -> String { let slices = self .point_slices @@ -1967,98 +2401,26 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let value = match instance.relation { - Stage3RelationKind::Stage3SpartanShift => { - expected_spartan_shift(store, evals, local_point)? - } - Stage3RelationKind::Stage3InstructionInput => { - expected_instruction_input(store, evals, local_point)? - } - Stage3RelationKind::Stage3RegistersClaimReduction => { - expected_registers(store, evals, local_point)? - } - relation => return Err(VerifyStage3Error::UnsupportedRelation { relation }), - }; + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage3Error::UnsupportedRelation { + relation: instance.relation, + })?; + let value = bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )?; expected += *coefficient * value; } Ok(expected) } -fn expected_spartan_shift( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage3NamedEval], - local_point: &[Fr], -) -> Result { - let opening_point = reverse_slice(local_point); - let eq_outer = - EqPlusOnePolynomial::::new(bolt_verifier_runtime::store_point(store, "stage3.input.stage1.NextPC")?.to_vec()) - .evaluate(&opening_point); - let eq_product = EqPlusOnePolynomial::::new( - bolt_verifier_runtime::store_point(store, "stage3.input.stage2.product_virtual.NextIsNoop")? - .to_vec(), - ) - .evaluate(&opening_point); - let weighted_outer = eval_by_name(evals, "stage3.spartan_shift.eval.UnexpandedPC")? - + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma")? - * eval_by_name(evals, "stage3.spartan_shift.eval.PC")? - + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma2")? - * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagVirtualInstruction")? - + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma3")? - * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagIsFirstInSequence")?; - Ok(eq_outer * weighted_outer - + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma4")? - * eq_product - * (Fr::from_u64(1) - - eval_by_name(evals, "stage3.spartan_shift.eval.InstructionFlagIsNoop")?)) -} - -fn expected_instruction_input( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage3NamedEval], - local_point: &[Fr], -) -> Result { - let opening_point = reverse_slice(local_point); - let eq_eval = EqPolynomial::::mle( - &opening_point, - bolt_verifier_runtime::store_point(store, "stage3.input.stage2.product_virtual.LeftInstructionInput")?, - ); - let left = eval_by_name( - evals, - "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value", - )? * eval_by_name(evals, "stage3.instruction_input.eval.Rs1Value")? - + eval_by_name( - evals, - "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC", - )? * eval_by_name(evals, "stage3.instruction_input.eval.UnexpandedPC")?; - let right = eval_by_name( - evals, - "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value", - )? * eval_by_name(evals, "stage3.instruction_input.eval.Rs2Value")? - + eval_by_name( - evals, - "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", - )? * eval_by_name(evals, "stage3.instruction_input.eval.Imm")?; - Ok(eq_eval * (right + bolt_verifier_runtime::store_scalar(store, "stage3.instruction_input.gamma")? * left)) -} - -fn expected_registers( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage3NamedEval], - local_point: &[Fr], -) -> Result { - let opening_point = reverse_slice(local_point); - let eq_eval = EqPolynomial::::mle( - &opening_point, - bolt_verifier_runtime::store_point(store, "stage3.input.stage1.RdWriteValue")?, - ); - Ok(eq_eval - * (eval_by_name(evals, "stage3.registers_claim_reduction.eval.RdWriteValue")? - + bolt_verifier_runtime::store_scalar(store, "stage3.registers.gamma")? - * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs1Value")? - + bolt_verifier_runtime::store_scalar(store, "stage3.registers.gamma2")? - * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs2Value")?)) -} - "# } } @@ -2073,6 +2435,26 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } +fn stage3_output_value_kind_expr(kind: &str) -> Result<&'static str, EmitError> { + match kind { + "eq_mle" => Ok("Stage3SumcheckOutputValueKind::EqMle"), + "eq_plus_one" => Ok("Stage3SumcheckOutputValueKind::EqPlusOne"), + _ => Err(EmitError::new(format!( + "unsupported stage3 output value kind `{kind}`" + ))), + } +} + +fn stage3_output_point_order_expr(point_order: &str) -> Result<&'static str, EmitError> { + match point_order { + "as_is" => Ok("Stage3SumcheckOutputPointOrder::AsIs"), + "reverse" => Ok("Stage3SumcheckOutputPointOrder::Reverse"), + _ => Err(EmitError::new(format!( + "unsupported stage3 output point order `{point_order}`" + ))), + } +} + fn emit_str_array(name: &str, values: &[String]) -> String { if values.is_empty() { return format!("pub const {name}: &[&str] = &[];\n\n"); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 034020ae9d..a951b72c5b 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -299,6 +299,34 @@ fn generated_opening_equality_mode(value: &str) -> bolt_verifier_runtime::Openin } } +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_sumcheck_output_value_kind( + value: &str, +) -> bolt_verifier_runtime::SumcheckOutputValueKind { + match value { + "eq_mle" => bolt_verifier_runtime::SumcheckOutputValueKind::EqMle, + "eq_plus_one" => bolt_verifier_runtime::SumcheckOutputValueKind::EqPlusOne, + value => panic!("unsupported generated sumcheck output value kind `{value}`"), + } +} + +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_sumcheck_output_point_order( + value: &str, +) -> bolt_verifier_runtime::SumcheckOutputPointOrder { + match value { + "as_is" => bolt_verifier_runtime::SumcheckOutputPointOrder::AsIs, + "reverse" => bolt_verifier_runtime::SumcheckOutputPointOrder::Reverse, + value => panic!("unsupported generated sumcheck output point order `{value}`"), + } +} + macro_rules! stage_program_step_kind { (kernel, $module:ident, $value:expr) => { super::leak_str($value) @@ -370,6 +398,7 @@ macro_rules! define_stage_adapter_impl { $(, transcript_absorb_bytes = $absorb:ident)? $(, kernels = $kernel:ident)? $(, point_zeros = $point_zero:ident)? + $(, output_claims = $output_claim:ident, output_values = $output_value:ident)? $(, opening_equalities = $opening_equality:ident)? ) => { pub fn $function(program: &$compiler) -> &'static $module::$program { @@ -518,6 +547,36 @@ macro_rules! define_stage_adapter_impl { .collect(), ), $( + output_claims: super::leak_slice( + program + .output_claims + .iter() + .map(|plan| $module::$output_claim { + relation: super::generated_relation_kind(&plan.relation), + local_values: super::leak_slice( + plan.local_values + .iter() + .map(|value| $module::$output_value { + symbol: super::leak_str(&value.symbol), + kind: super::generated_sumcheck_output_value_kind(&value.kind), + point_order: super::generated_sumcheck_output_point_order( + &value.point_order, + ), + local_point_source: super::leak_str( + &value.local_point_source, + ), + opening_point_source: super::leak_str( + &value.opening_point_source, + ), + }) + .collect(), + ), + claim_value: super::leak_str(&plan.claim_value), + }) + .collect(), + ), + )? + $( point_zeros: super::leak_slice( program .point_zeros @@ -684,6 +743,7 @@ macro_rules! define_stage_adapter_no_absorb { $opening_claim:ident, $opening_batch:ident $(, kernels = $kernel:ident)? + $(, output_claims = $output_claim:ident, output_values = $output_value:ident)? $(, opening_equalities = $opening_equality:ident)? ) => { define_stage_adapter_impl!( @@ -708,6 +768,7 @@ macro_rules! define_stage_adapter_no_absorb { $opening_claim, $opening_batch $(, kernels = $kernel)? + $(, output_claims = $output_claim, output_values = $output_value)? $(, opening_equalities = $opening_equality)? ); }; diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs index 5dcb77bf10..5de0452d48 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs @@ -22,5 +22,7 @@ define_stage_adapter_no_absorb!( Stage3PointConcatPlan, Stage3OpeningClaimPlan, Stage3OpeningBatchPlan, + output_claims = Stage3SumcheckOutputClaimPlan, + output_values = Stage3SumcheckOutputValuePlan, opening_equalities = Stage3OpeningClaimEqualityPlan ); diff --git a/crates/jolt-verifier/src/lib.rs b/crates/jolt-verifier/src/lib.rs index 90f218a585..18f0a856a2 100644 --- a/crates/jolt-verifier/src/lib.rs +++ b/crates/jolt-verifier/src/lib.rs @@ -23,8 +23,8 @@ pub use verifier::{ JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, JoltVerificationArtifacts, JoltVerifierCheckpoint, JoltVerifierInputs, - JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepKind, - JoltVerifierStepPlan, JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, + JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepPlan, + JoltVerifierStepKind, JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, JOLT_TARGET_FULL, JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6, JOLT_TARGET_THROUGH_STAGE7, JOLT_VERIFIER_STEPS, JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM, }; diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index e45b6e0c53..6aef80af9e 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -1,8 +1,7 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; +use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; use jolt_field::{Field, Fr}; -use jolt_poly::{EqPlusOnePolynomial, EqPolynomial}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, Transcript}; @@ -18,6 +17,8 @@ pub type Stage3VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgram pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage3SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage3SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage3SumcheckOutputValuePlan = bolt_verifier_runtime::SumcheckOutputValuePlan; pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind; pub use bolt_verifier_runtime::{ @@ -32,6 +33,8 @@ pub use bolt_verifier_runtime::{ ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, + SumcheckOutputPointOrder as Stage3SumcheckOutputPointOrder, + SumcheckOutputValueKind as Stage3SumcheckOutputValueKind, TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, }; @@ -104,6 +107,31 @@ pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[ Stage3FieldExprPlan { symbol: "stage3.registers.term.Rs2Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.gamma2", "stage3.input.stage1.Rs2Value"] }, Stage3FieldExprPlan { symbol: "stage3.registers.partial.RdWriteValueRs1Value", kind: Stage3FieldExprKind::Add, operands: &["stage3.input.stage1.RdWriteValue", "stage3.registers.term.Rs1Value"] }, Stage3FieldExprPlan { symbol: "stage3.registers.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers.partial.RdWriteValueRs1Value", "stage3.registers.term.Rs2Value"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.term.PC", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma", "stage3.spartan_shift.eval.PC"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma2", "stage3.spartan_shift.eval.OpFlagVirtualInstruction"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma3", "stage3.spartan_shift.eval.OpFlagIsFirstInSequence"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", kind: Stage3FieldExprKind::Sub, operands: &["stage3.field.one", "stage3.spartan_shift.eval.InstructionFlagIsNoop"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.partial.PC", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.eval.UnexpandedPC", "stage3.spartan_shift.output.term.PC"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.output.partial.PC", "stage3.spartan_shift.output.term.OpFlagVirtualInstruction"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.weighted_outer", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.outer", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.output.eq.NextPC", "stage3.spartan_shift.output.weighted_outer"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.noop_product", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.output.eq.NextIsNoop", "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.noop_term", kind: Stage3FieldExprKind::Mul, operands: &["stage3.spartan_shift.gamma4", "stage3.spartan_shift.output.noop_product"] }, + Stage3FieldExprPlan { symbol: "stage3.spartan_shift.output.claim_expr", kind: Stage3FieldExprKind::Add, operands: &["stage3.spartan_shift.output.outer", "stage3.spartan_shift.output.noop_term"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.left.term.Rs1Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.eval.Rs1Value"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.left.term.PC", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.eval.UnexpandedPC"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.left", kind: Stage3FieldExprKind::Add, operands: &["stage3.instruction_input.output.left.term.Rs1Value", "stage3.instruction_input.output.left.term.PC"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.right.term.Rs2Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.eval.Rs2Value"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.right.term.Imm", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", "stage3.instruction_input.eval.Imm"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.right", kind: Stage3FieldExprKind::Add, operands: &["stage3.instruction_input.output.right.term.Rs2Value", "stage3.instruction_input.output.right.term.Imm"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.left_weighted", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.gamma", "stage3.instruction_input.output.left"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.weighted_inputs", kind: Stage3FieldExprKind::Add, operands: &["stage3.instruction_input.output.right", "stage3.instruction_input.output.left_weighted"] }, + Stage3FieldExprPlan { symbol: "stage3.instruction_input.output.claim_expr", kind: Stage3FieldExprKind::Mul, operands: &["stage3.instruction_input.output.eq.LeftInstructionInput", "stage3.instruction_input.output.weighted_inputs"] }, + Stage3FieldExprPlan { symbol: "stage3.registers.output.term.Rs1Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.gamma", "stage3.registers_claim_reduction.eval.Rs1Value"] }, + Stage3FieldExprPlan { symbol: "stage3.registers.output.term.Rs2Value", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.gamma2", "stage3.registers_claim_reduction.eval.Rs2Value"] }, + Stage3FieldExprPlan { symbol: "stage3.registers.output.partial.RdWriteValueRs1Value", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers_claim_reduction.eval.RdWriteValue", "stage3.registers.output.term.Rs1Value"] }, + Stage3FieldExprPlan { symbol: "stage3.registers.output.weighted_register_values", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers.output.partial.RdWriteValueRs1Value", "stage3.registers.output.term.Rs2Value"] }, + Stage3FieldExprPlan { symbol: "stage3.registers.output.claim_expr", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.output.eq.RdWriteValue", "stage3.registers.output.weighted_register_values"] }, ]; pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[ Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr" }, @@ -179,6 +207,25 @@ pub const STAGE3_OPENING_EQUALITIES: &[Stage3OpeningClaimEqualityPlan] = &[ pub const STAGE3_OPENING_BATCHES: &[Stage3OpeningBatchPlan] = &[ Stage3OpeningBatchPlan { symbol: "stage3.openings", stage: "stage3", proof_slot: "stage3.openings", policy: "jolt_stage3_output_order", count: 16, ordered_claims: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"], claim_operands: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"] }, ]; +pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage3SumcheckOutputValuePlan] = &[ + Stage3SumcheckOutputValuePlan { symbol: "stage3.spartan_shift.output.eq.NextPC", kind: Stage3SumcheckOutputValueKind::EqPlusOne, point_order: Stage3SumcheckOutputPointOrder::Reverse, local_point_source: "stage3.spartan_shift.instance", opening_point_source: "stage3.input.stage1.NextPC" }, + Stage3SumcheckOutputValuePlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", kind: Stage3SumcheckOutputValueKind::EqPlusOne, point_order: Stage3SumcheckOutputPointOrder::Reverse, local_point_source: "stage3.spartan_shift.instance", opening_point_source: "stage3.input.stage2.product_virtual.NextIsNoop" }, +]; + +pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage3SumcheckOutputValuePlan] = &[ + Stage3SumcheckOutputValuePlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", kind: Stage3SumcheckOutputValueKind::EqMle, point_order: Stage3SumcheckOutputPointOrder::Reverse, local_point_source: "stage3.instruction_input.instance", opening_point_source: "stage3.input.stage2.product_virtual.LeftInstructionInput" }, +]; + +pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage3SumcheckOutputValuePlan] = &[ + Stage3SumcheckOutputValuePlan { symbol: "stage3.registers.output.eq.RdWriteValue", kind: Stage3SumcheckOutputValueKind::EqMle, point_order: Stage3SumcheckOutputPointOrder::Reverse, local_point_source: "stage3.registers_claim_reduction.instance", opening_point_source: "stage3.input.stage1.RdWriteValue" }, +]; + +pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[ + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, local_values: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage3.spartan_shift.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, local_values: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage3.instruction_input.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, local_values: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, claim_value: "stage3.registers.output.claim_expr" }, +]; + pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { params: STAGE3_PARAMS, steps: STAGE3_PROGRAM_STEPS, @@ -191,6 +238,7 @@ pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan drivers: STAGE3_SUMCHECK_DRIVERS, instance_results: STAGE3_SUMCHECK_INSTANCE_RESULTS, evals: STAGE3_SUMCHECK_EVALS, + output_claims: STAGE3_SUMCHECK_OUTPUT_CLAIMS, point_slices: STAGE3_POINT_SLICES, point_concats: STAGE3_POINT_CONCATS, opening_claims: STAGE3_OPENING_CLAIMS, @@ -427,94 +475,22 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let value = match instance.relation { - Stage3RelationKind::Stage3SpartanShift => { - expected_spartan_shift(store, evals, local_point)? - } - Stage3RelationKind::Stage3InstructionInput => { - expected_instruction_input(store, evals, local_point)? - } - Stage3RelationKind::Stage3RegistersClaimReduction => { - expected_registers(store, evals, local_point)? - } - relation => return Err(VerifyStage3Error::UnsupportedRelation { relation }), - }; + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage3Error::UnsupportedRelation { + relation: instance.relation, + })?; + let value = bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )?; expected += *coefficient * value; } Ok(expected) } - -fn expected_spartan_shift( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage3NamedEval], - local_point: &[Fr], -) -> Result { - let opening_point = reverse_slice(local_point); - let eq_outer = - EqPlusOnePolynomial::::new(bolt_verifier_runtime::store_point(store, "stage3.input.stage1.NextPC")?.to_vec()) - .evaluate(&opening_point); - let eq_product = EqPlusOnePolynomial::::new( - bolt_verifier_runtime::store_point(store, "stage3.input.stage2.product_virtual.NextIsNoop")? - .to_vec(), - ) - .evaluate(&opening_point); - let weighted_outer = eval_by_name(evals, "stage3.spartan_shift.eval.UnexpandedPC")? - + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma")? - * eval_by_name(evals, "stage3.spartan_shift.eval.PC")? - + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma2")? - * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagVirtualInstruction")? - + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma3")? - * eval_by_name(evals, "stage3.spartan_shift.eval.OpFlagIsFirstInSequence")?; - Ok(eq_outer * weighted_outer - + bolt_verifier_runtime::store_scalar(store, "stage3.spartan_shift.gamma4")? - * eq_product - * (Fr::from_u64(1) - - eval_by_name(evals, "stage3.spartan_shift.eval.InstructionFlagIsNoop")?)) -} - -fn expected_instruction_input( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage3NamedEval], - local_point: &[Fr], -) -> Result { - let opening_point = reverse_slice(local_point); - let eq_eval = EqPolynomial::::mle( - &opening_point, - bolt_verifier_runtime::store_point(store, "stage3.input.stage2.product_virtual.LeftInstructionInput")?, - ); - let left = eval_by_name( - evals, - "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value", - )? * eval_by_name(evals, "stage3.instruction_input.eval.Rs1Value")? - + eval_by_name( - evals, - "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC", - )? * eval_by_name(evals, "stage3.instruction_input.eval.UnexpandedPC")?; - let right = eval_by_name( - evals, - "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value", - )? * eval_by_name(evals, "stage3.instruction_input.eval.Rs2Value")? - + eval_by_name( - evals, - "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", - )? * eval_by_name(evals, "stage3.instruction_input.eval.Imm")?; - Ok(eq_eval * (right + bolt_verifier_runtime::store_scalar(store, "stage3.instruction_input.gamma")? * left)) -} - -fn expected_registers( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage3NamedEval], - local_point: &[Fr], -) -> Result { - let opening_point = reverse_slice(local_point); - let eq_eval = EqPolynomial::::mle( - &opening_point, - bolt_verifier_runtime::store_point(store, "stage3.input.stage1.RdWriteValue")?, - ); - Ok(eq_eval - * (eval_by_name(evals, "stage3.registers_claim_reduction.eval.RdWriteValue")? - + bolt_verifier_runtime::store_scalar(store, "stage3.registers.gamma")? - * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs1Value")? - + bolt_verifier_runtime::store_scalar(store, "stage3.registers.gamma2")? - * eval_by_name(evals, "stage3.registers_claim_reduction.eval.Rs2Value")?)) -} From 55d18d2fc180231c0c1cc6deeb33fbd5f1e7d9cd Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 11:07:07 -0600 Subject: [PATCH 021/171] refactor(bolt): own stage3 output claims in IR Add first-class sumcheck output value and claim ops across Bolt IR, schema validation, Stage 3 lowering, kernel resolution, and CPU lowering. Stage 3 now emits protocol-owned output-claim plans, and the Rust emitter reads those ops instead of building verifier formulas by hand.\n\nReplace clone-based runtime output-claim evaluation with a scratch scalar overlay, and keep verifier-only output formula closures out of prover generated artifacts. --- crates/bolt-verifier-runtime/src/lib.rs | 62 +- crates/bolt/irdl/compute.mlir | 30 + crates/bolt/irdl/cpu.mlir | 30 + crates/bolt/irdl/piop.mlir | 30 + .../src/protocols/jolt/emit/rust/stage3.rs | 467 ++++------- .../src/protocols/jolt/phases/commitment.rs | 27 + .../src/protocols/jolt/phases/lowering.rs | 27 + .../bolt/src/protocols/jolt/phases/stage1.rs | 27 + .../bolt/src/protocols/jolt/phases/stage3.rs | 775 ++++++++++++++++-- crates/bolt/src/schema.rs | 87 ++ 10 files changed, 1181 insertions(+), 381 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 885a334d41..37d2e26018 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -1116,9 +1116,9 @@ pub fn evaluate_sumcheck_output_claim( evals: &[StageNamedEval], local_point: &[Fr], ) -> Result { - let mut scratch = store.clone(); + let mut scratch = Vec::new(); for eval in evals { - scratch.insert_scalar(eval.name, eval.value); + insert_scratch_scalar(&mut scratch, eval.name, eval.value); } for local_value in plan.local_values { if local_value.local_point_source != instance_symbol { @@ -1127,7 +1127,7 @@ pub fn evaluate_sumcheck_output_claim( reason: "sumcheck output value source mismatch", }); } - let opening_point = scratch.point_or(local_value.opening_point_source, |symbol| { + let opening_point = store.point_or(local_value.opening_point_source, |symbol| { RuntimePlanError::MissingValue { symbol } })?; let ordered_point = match local_value.point_order { @@ -1142,14 +1142,62 @@ pub fn evaluate_sumcheck_output_claim( EqPlusOnePolynomial::::new(opening_point.to_vec()).evaluate(&ordered_point) } }; - scratch.insert_scalar(local_value.symbol, value); + insert_scratch_scalar(&mut scratch, local_value.symbol, value); } - scratch.evaluate_available_field_exprs(field_exprs, evaluate_field_expr)?; - scratch.scalar_or(plan.claim_value, |symbol| RuntimePlanError::MissingValue { - symbol, + evaluate_available_field_exprs_with_scratch(field_exprs, store, &mut scratch)?; + scratch_scalar_or(store, &scratch, plan.claim_value).ok_or(RuntimePlanError::MissingValue { + symbol: plan.claim_value, }) } +fn insert_scratch_scalar(scratch: &mut Vec<(&'static str, Fr)>, symbol: &'static str, value: Fr) { + if let Some((_, existing)) = scratch.iter_mut().find(|(name, _)| *name == symbol) { + *existing = value; + } else { + scratch.push((symbol, value)); + } +} + +fn scratch_scalar_or( + store: &ValueStore, + scratch: &[(&'static str, Fr)], + symbol: &'static str, +) -> Option { + scratch + .iter() + .find(|(name, _)| *name == symbol) + .map(|(_, value)| *value) + .or_else(|| store.try_scalar(symbol)) +} + +fn evaluate_available_field_exprs_with_scratch( + field_exprs: &[FieldExprPlan], + store: &ValueStore, + scratch: &mut Vec<(&'static str, Fr)>, +) -> Result<(), RuntimePlanError> { + loop { + let mut progress = 0usize; + for expr in field_exprs { + if scratch_scalar_or(store, scratch, expr.symbol).is_some() { + continue; + } + let Some(operands) = expr + .operands + .iter() + .map(|operand| scratch_scalar_or(store, scratch, operand)) + .collect::>>() + else { + continue; + }; + insert_scratch_scalar(scratch, expr.symbol, evaluate_field_expr(expr, &operands)?); + progress += 1; + } + if progress == 0 { + return Ok(()); + } + } +} + pub fn indexed_evals_by_prefix( evals: &[StageNamedEval], prefix: &'static str, diff --git a/crates/bolt/irdl/compute.mlir b/crates/bolt/irdl/compute.mlir index 60c01c9eaa..7f2626d77d 100644 --- a/crates/bolt/irdl/compute.mlir +++ b/crates/bolt/irdl/compute.mlir @@ -670,6 +670,36 @@ irdl.dialect @compute { irdl.operands(input_point: %input_point, input_result: %input_result) irdl.results(instance_point: %output_point, instance_result: %output_result) } + irdl.operation @sumcheck_output_value { + %point = irdl.parametric @compute::@point<> + %value = irdl.parametric @compute::@field_value<> + %sym = irdl.any + %kind = irdl.any + %point_order = irdl.any + irdl.attributes { + "sym_name" = %sym, + "kind" = %kind, + "point_order" = %point_order + } + irdl.operands(local_point: %point, opening_point: %point) + irdl.results(value: %value) + } + irdl.operation @sumcheck_output_claim { + %value = irdl.parametric @compute::@field_value<> + %sym = irdl.any + %stage = irdl.any + %relation = irdl.any + %count = irdl.any + %local_values = irdl.any + irdl.attributes { + "sym_name" = %sym, + "stage" = %stage, + "relation" = %relation, + "count" = %count, + "local_values" = %local_values + } + irdl.operands(claim_value: %value, local_values: variadic %value) + } irdl.operation @opening_claim { %point = irdl.parametric @compute::@point<> %eval = irdl.parametric @compute::@field_value<> diff --git a/crates/bolt/irdl/cpu.mlir b/crates/bolt/irdl/cpu.mlir index 22fe7ad519..d115906834 100644 --- a/crates/bolt/irdl/cpu.mlir +++ b/crates/bolt/irdl/cpu.mlir @@ -600,6 +600,36 @@ irdl.dialect @cpu { irdl.operands(input_point: %input_point, input_result: %input_result) irdl.results(instance_point: %output_point, instance_result: %output_result) } + irdl.operation @sumcheck_output_value { + %point = irdl.parametric @cpu::@point<> + %value = irdl.parametric @cpu::@field_value<> + %sym = irdl.any + %kind = irdl.any + %point_order = irdl.any + irdl.attributes { + "sym_name" = %sym, + "kind" = %kind, + "point_order" = %point_order + } + irdl.operands(local_point: %point, opening_point: %point) + irdl.results(value: %value) + } + irdl.operation @sumcheck_output_claim { + %value = irdl.parametric @cpu::@field_value<> + %sym = irdl.any + %stage = irdl.any + %relation = irdl.any + %count = irdl.any + %local_values = irdl.any + irdl.attributes { + "sym_name" = %sym, + "stage" = %stage, + "relation" = %relation, + "count" = %count, + "local_values" = %local_values + } + irdl.operands(claim_value: %value, local_values: variadic %value) + } irdl.operation @opening_claim { %point = irdl.parametric @cpu::@point<> %eval = irdl.parametric @cpu::@field_value<> diff --git a/crates/bolt/irdl/piop.mlir b/crates/bolt/irdl/piop.mlir index 169bc5c9ab..d70915e52f 100644 --- a/crates/bolt/irdl/piop.mlir +++ b/crates/bolt/irdl/piop.mlir @@ -218,6 +218,36 @@ irdl.dialect @piop { irdl.operands(input_point: %input_point, input_result: %input_result) irdl.results(instance_point: %output_point, instance_result: %output_result) } + irdl.operation @sumcheck_output_value { + %point = irdl.parametric @poly::@point<> + %value = irdl.parametric @field::@scalar<> + %sym = irdl.any + %kind = irdl.any + %point_order = irdl.any + irdl.attributes { + "sym_name" = %sym, + "kind" = %kind, + "point_order" = %point_order + } + irdl.operands(local_point: %point, opening_point: %point) + irdl.results(value: %value) + } + irdl.operation @sumcheck_output_claim { + %value = irdl.parametric @field::@scalar<> + %sym = irdl.any + %stage = irdl.any + %relation = irdl.any + %count = irdl.any + %local_values = irdl.any + irdl.attributes { + "sym_name" = %sym, + "stage" = %stage, + "relation" = %relation, + "count" = %count, + "local_values" = %local_values + } + irdl.operands(claim_value: %value, local_values: variadic %value) + } irdl.operation @opening_claim { %point = irdl.parametric @poly::@point<> %eval = irdl.parametric @field::@scalar<> diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 7651769023..2481c5a4fe 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -23,6 +23,7 @@ pub struct Stage3CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, + pub output_values: Vec, pub output_claims: Vec, pub point_slices: Vec, pub point_concats: Vec, @@ -162,6 +163,14 @@ pub struct Stage3SumcheckOutputClaimPlan { pub claim_value: String, } +#[derive(Clone, Debug, PartialEq, Eq)] +struct Stage3SumcheckOutputClaimAst { + relation: String, + claim_value: String, + local_values: Vec, + local_value_operands: Vec, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage3SumcheckEvalPlan { pub symbol: String, @@ -234,294 +243,6 @@ pub fn emit_stage3_rust(module: &BoltModule<'_, Cpu>) -> Result Stage3FieldExprPlan { - Stage3FieldExprPlan { - symbol: symbol.to_owned(), - kind: "op".to_owned(), - formula: formula.to_owned(), - operand_names: operands - .iter() - .map(|operand| (*operand).to_owned()) - .collect(), - operands: operands - .iter() - .map(|operand| (*operand).to_owned()) - .collect(), - } -} - -fn stage3_output_value( - symbol: &str, - kind: &str, - local_point_source: &str, - opening_point_source: &str, -) -> Stage3SumcheckOutputValuePlan { - Stage3SumcheckOutputValuePlan { - symbol: symbol.to_owned(), - kind: kind.to_owned(), - point_order: "reverse".to_owned(), - local_point_source: local_point_source.to_owned(), - opening_point_source: opening_point_source.to_owned(), - } -} - -fn stage3_output_claim( - relation: &str, - local_values: Vec, - claim_value: &str, -) -> Stage3SumcheckOutputClaimPlan { - Stage3SumcheckOutputClaimPlan { - relation: relation.to_owned(), - local_values, - claim_value: claim_value.to_owned(), - } -} - -fn stage3_verifier_output_field_exprs() -> Vec { - vec![ - stage3_field_expr( - "stage3.spartan_shift.output.term.PC", - "field.mul", - &["stage3.spartan_shift.gamma", "stage3.spartan_shift.eval.PC"], - ), - stage3_field_expr( - "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", - "field.mul", - &[ - "stage3.spartan_shift.gamma2", - "stage3.spartan_shift.eval.OpFlagVirtualInstruction", - ], - ), - stage3_field_expr( - "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", - "field.mul", - &[ - "stage3.spartan_shift.gamma3", - "stage3.spartan_shift.eval.OpFlagIsFirstInSequence", - ], - ), - stage3_field_expr( - "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", - "field.sub", - &[ - "stage3.field.one", - "stage3.spartan_shift.eval.InstructionFlagIsNoop", - ], - ), - stage3_field_expr( - "stage3.spartan_shift.output.partial.PC", - "field.add", - &[ - "stage3.spartan_shift.eval.UnexpandedPC", - "stage3.spartan_shift.output.term.PC", - ], - ), - stage3_field_expr( - "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", - "field.add", - &[ - "stage3.spartan_shift.output.partial.PC", - "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", - ], - ), - stage3_field_expr( - "stage3.spartan_shift.output.weighted_outer", - "field.add", - &[ - "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", - "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", - ], - ), - stage3_field_expr( - "stage3.spartan_shift.output.outer", - "field.mul", - &[ - "stage3.spartan_shift.output.eq.NextPC", - "stage3.spartan_shift.output.weighted_outer", - ], - ), - stage3_field_expr( - "stage3.spartan_shift.output.noop_product", - "field.mul", - &[ - "stage3.spartan_shift.output.eq.NextIsNoop", - "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", - ], - ), - stage3_field_expr( - "stage3.spartan_shift.output.noop_term", - "field.mul", - &[ - "stage3.spartan_shift.gamma4", - "stage3.spartan_shift.output.noop_product", - ], - ), - stage3_field_expr( - "stage3.spartan_shift.output.claim_expr", - "field.add", - &[ - "stage3.spartan_shift.output.outer", - "stage3.spartan_shift.output.noop_term", - ], - ), - stage3_field_expr( - "stage3.instruction_input.output.left.term.Rs1Value", - "field.mul", - &[ - "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value", - "stage3.instruction_input.eval.Rs1Value", - ], - ), - stage3_field_expr( - "stage3.instruction_input.output.left.term.PC", - "field.mul", - &[ - "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC", - "stage3.instruction_input.eval.UnexpandedPC", - ], - ), - stage3_field_expr( - "stage3.instruction_input.output.left", - "field.add", - &[ - "stage3.instruction_input.output.left.term.Rs1Value", - "stage3.instruction_input.output.left.term.PC", - ], - ), - stage3_field_expr( - "stage3.instruction_input.output.right.term.Rs2Value", - "field.mul", - &[ - "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value", - "stage3.instruction_input.eval.Rs2Value", - ], - ), - stage3_field_expr( - "stage3.instruction_input.output.right.term.Imm", - "field.mul", - &[ - "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", - "stage3.instruction_input.eval.Imm", - ], - ), - stage3_field_expr( - "stage3.instruction_input.output.right", - "field.add", - &[ - "stage3.instruction_input.output.right.term.Rs2Value", - "stage3.instruction_input.output.right.term.Imm", - ], - ), - stage3_field_expr( - "stage3.instruction_input.output.left_weighted", - "field.mul", - &[ - "stage3.instruction_input.gamma", - "stage3.instruction_input.output.left", - ], - ), - stage3_field_expr( - "stage3.instruction_input.output.weighted_inputs", - "field.add", - &[ - "stage3.instruction_input.output.right", - "stage3.instruction_input.output.left_weighted", - ], - ), - stage3_field_expr( - "stage3.instruction_input.output.claim_expr", - "field.mul", - &[ - "stage3.instruction_input.output.eq.LeftInstructionInput", - "stage3.instruction_input.output.weighted_inputs", - ], - ), - stage3_field_expr( - "stage3.registers.output.term.Rs1Value", - "field.mul", - &[ - "stage3.registers.gamma", - "stage3.registers_claim_reduction.eval.Rs1Value", - ], - ), - stage3_field_expr( - "stage3.registers.output.term.Rs2Value", - "field.mul", - &[ - "stage3.registers.gamma2", - "stage3.registers_claim_reduction.eval.Rs2Value", - ], - ), - stage3_field_expr( - "stage3.registers.output.partial.RdWriteValueRs1Value", - "field.add", - &[ - "stage3.registers_claim_reduction.eval.RdWriteValue", - "stage3.registers.output.term.Rs1Value", - ], - ), - stage3_field_expr( - "stage3.registers.output.weighted_register_values", - "field.add", - &[ - "stage3.registers.output.partial.RdWriteValueRs1Value", - "stage3.registers.output.term.Rs2Value", - ], - ), - stage3_field_expr( - "stage3.registers.output.claim_expr", - "field.mul", - &[ - "stage3.registers.output.eq.RdWriteValue", - "stage3.registers.output.weighted_register_values", - ], - ), - ] -} - -fn stage3_verifier_output_claims() -> Vec { - vec![ - stage3_output_claim( - "jolt.stage3.spartan_shift", - vec![ - stage3_output_value( - "stage3.spartan_shift.output.eq.NextPC", - "eq_plus_one", - "stage3.spartan_shift.instance", - "stage3.input.stage1.NextPC", - ), - stage3_output_value( - "stage3.spartan_shift.output.eq.NextIsNoop", - "eq_plus_one", - "stage3.spartan_shift.instance", - "stage3.input.stage2.product_virtual.NextIsNoop", - ), - ], - "stage3.spartan_shift.output.claim_expr", - ), - stage3_output_claim( - "jolt.stage3.instruction_input", - vec![stage3_output_value( - "stage3.instruction_input.output.eq.LeftInstructionInput", - "eq_mle", - "stage3.instruction_input.instance", - "stage3.input.stage2.product_virtual.LeftInstructionInput", - )], - "stage3.instruction_input.output.claim_expr", - ), - stage3_output_claim( - "jolt.stage3.registers_claim_reduction", - vec![stage3_output_value( - "stage3.registers.output.eq.RdWriteValue", - "eq_mle", - "stage3.registers_claim_reduction.instance", - "stage3.input.stage1.RdWriteValue", - )], - "stage3.registers.output.claim_expr", - ), - ] -} - impl Stage3CpuProgram { fn from_module(module: &BoltModule<'_, Cpu>) -> Result { let mut params = None; @@ -536,6 +257,8 @@ impl Stage3CpuProgram { let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); + let mut output_values = Vec::new(); + let mut output_claim_asts = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); let mut opening_claims = Vec::new(); @@ -750,6 +473,23 @@ impl Stage3CpuProgram { oracle: symbol_attr(op, "oracle")?, }); } + "cpu.sumcheck_output_value" => { + output_values.push(Stage3SumcheckOutputValuePlan { + symbol: string_attr(op, "sym_name")?, + kind: string_attr(op, "kind")?, + point_order: string_attr(op, "point_order")?, + local_point_source: operand_symbol(op, 0)?, + opening_point_source: operand_symbol(op, 1)?, + }); + } + "cpu.sumcheck_output_claim" => { + output_claim_asts.push(Stage3SumcheckOutputClaimAst { + relation: symbol_attr(op, "relation")?, + claim_value: operand_symbol(op, 0)?, + local_values: symbol_array_attr(op, "local_values")?, + local_value_operands: operand_symbols(op, 1)?, + }); + } "cpu.point_slice" => { point_slices.push(Stage3PointSlicePlan { symbol: string_attr(op, "sym_name")?, @@ -804,11 +544,11 @@ impl Stage3CpuProgram { let role = module .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; - if role == Role::Verifier { - field_exprs.extend(stage3_verifier_output_field_exprs()); + if role == Role::Prover { + prune_prover_output_field_exprs(&mut field_exprs, &claims, &output_claim_asts); } let output_claims = if role == Role::Verifier { - stage3_verifier_output_claims() + resolve_stage3_output_claims(&output_values, output_claim_asts)? } else { Vec::new() }; @@ -827,6 +567,7 @@ impl Stage3CpuProgram { drivers, instance_results, evals, + output_values, output_claims, point_slices, point_concats, @@ -922,9 +663,9 @@ impl Stage3CpuProgram { )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); - values.extend(symbols(self.output_claims.iter().flat_map(|claim| { - claim.local_values.iter().map(|value| &value.symbol) - }))); + values.extend(symbols( + self.output_values.iter().map(|value| &value.symbol), + )); values } @@ -1123,6 +864,32 @@ impl Stage3CpuProgram { ); let field_values = self.field_value_symbols(); let point_values = self.point_value_symbols(); + for local_value in &self.output_values { + if !point_values.contains(&local_value.local_point_source) { + return Err(EmitError::new(format!( + "stage3 output value @{} references missing local point @{}", + local_value.symbol, local_value.local_point_source + ))); + } + if !point_values.contains(&local_value.opening_point_source) { + return Err(EmitError::new(format!( + "stage3 output value @{} references missing opening point @{}", + local_value.symbol, local_value.opening_point_source + ))); + } + if !matches!(local_value.kind.as_str(), "eq_mle" | "eq_plus_one") { + return Err(EmitError::new(format!( + "stage3 output value @{} has unsupported kind `{}`", + local_value.symbol, local_value.kind + ))); + } + if !matches!(local_value.point_order.as_str(), "as_is" | "reverse") { + return Err(EmitError::new(format!( + "stage3 output value @{} has unsupported point order `{}`", + local_value.symbol, local_value.point_order + ))); + } + } for claim in &self.output_claims { if !relations.contains(&claim.relation) { return Err(EmitError::new(format!( @@ -1136,32 +903,6 @@ impl Stage3CpuProgram { claim.relation, claim.claim_value ))); } - for local_value in &claim.local_values { - if !point_values.contains(&local_value.local_point_source) { - return Err(EmitError::new(format!( - "stage3 output value @{} references missing local point @{}", - local_value.symbol, local_value.local_point_source - ))); - } - if !point_values.contains(&local_value.opening_point_source) { - return Err(EmitError::new(format!( - "stage3 output value @{} references missing opening point @{}", - local_value.symbol, local_value.opening_point_source - ))); - } - if !matches!(local_value.kind.as_str(), "eq_mle" | "eq_plus_one") { - return Err(EmitError::new(format!( - "stage3 output value @{} has unsupported kind `{}`", - local_value.symbol, local_value.kind - ))); - } - if !matches!(local_value.point_order.as_str(), "as_is" | "reverse") { - return Err(EmitError::new(format!( - "stage3 output value @{} has unsupported point order `{}`", - local_value.symbol, local_value.point_order - ))); - } - } } Ok(()) } @@ -2435,6 +2176,92 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } +fn resolve_stage3_output_claims( + output_values: &[Stage3SumcheckOutputValuePlan], + claim_asts: Vec, +) -> Result, EmitError> { + let output_values_by_symbol: BTreeMap<_, _> = output_values + .iter() + .map(|value| (value.symbol.as_str(), value)) + .collect(); + claim_asts + .into_iter() + .map(|claim| { + if claim.local_values != claim.local_value_operands { + return Err(EmitError::new(format!( + "stage3 output claim for @{} operand order does not match local_values", + claim.relation + ))); + } + let local_values = claim + .local_values + .iter() + .map(|symbol| { + output_values_by_symbol + .get(symbol.as_str()) + .map(|value| (*value).clone()) + .ok_or_else(|| { + EmitError::new(format!( + "stage3 output claim for @{} references missing output value @{symbol}", + claim.relation + )) + }) + }) + .collect::, EmitError>>()?; + Ok(Stage3SumcheckOutputClaimPlan { + relation: claim.relation, + local_values, + claim_value: claim.claim_value, + }) + }) + .collect() +} + +fn prune_prover_output_field_exprs( + field_exprs: &mut Vec, + claims: &[Stage3SumcheckClaimPlan], + output_claims: &[Stage3SumcheckOutputClaimAst], +) { + let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs + .iter() + .map(|expr| (expr.symbol.as_str(), expr)) + .collect(); + let sumcheck_claim_closure = field_expr_dependency_closure( + &field_exprs_by_symbol, + claims.iter().map(|claim| claim.claim_value.as_str()), + ); + let output_claim_closure = field_expr_dependency_closure( + &field_exprs_by_symbol, + output_claims.iter().map(|claim| claim.claim_value.as_str()), + ); + field_exprs.retain(|expr| { + !output_claim_closure.contains(&expr.symbol) + || sumcheck_claim_closure.contains(&expr.symbol) + }); +} + +fn field_expr_dependency_closure<'a>( + field_exprs_by_symbol: &BTreeMap<&str, &Stage3FieldExprPlan>, + roots: impl Iterator, +) -> BTreeSet { + let mut visited = BTreeSet::new(); + let mut stack = roots.map(str::to_owned).collect::>(); + while let Some(symbol) = stack.pop() { + if !visited.insert(symbol.clone()) { + continue; + } + let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { + continue; + }; + for operand in &expr.operands { + if field_exprs_by_symbol.contains_key(operand.as_str()) { + stack.push(operand.clone()); + } + } + } + visited +} + fn stage3_output_value_kind_expr(kind: &str) -> Result<&'static str, EmitError> { match kind { "eq_mle" => Ok("Stage3SumcheckOutputValueKind::EqMle"), diff --git a/crates/bolt/src/protocols/jolt/phases/commitment.rs b/crates/bolt/src/protocols/jolt/phases/commitment.rs index 10327884cd..69f94cef38 100644 --- a/crates/bolt/src/protocols/jolt/phases/commitment.rs +++ b/crates/bolt/src/protocols/jolt/phases/commitment.rs @@ -922,6 +922,33 @@ pub fn lower_compute_to_cpu<'c>( insert_result_mapping(&mut value_map, op, operation, 0, 0)?; insert_result_mapping(&mut value_map, op, operation, 1, 1)?; } + "compute.sumcheck_output_value" => { + let operands = lowered_operands(op, &value_map)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs(op, &["kind", "point_order"])?; + let operation = context.append_typed_op_with_owned_attrs( + &cpu, + "cpu.sumcheck_output_value", + Some(&symbol), + &attrs, + &operands, + &["!cpu.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } + "compute.sumcheck_output_claim" => { + let operands = lowered_operands(op, &value_map)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs(op, &["stage", "relation", "count", "local_values"])?; + let _operation = context.append_typed_op_with_owned_attrs( + &cpu, + "cpu.sumcheck_output_claim", + Some(&symbol), + &attrs, + &operands, + &[], + )?; + } "compute.opening_claim" => { let operands = lowered_operands(op, &value_map)?; let symbol = string_attr(op, "sym_name")?; diff --git a/crates/bolt/src/protocols/jolt/phases/lowering.rs b/crates/bolt/src/protocols/jolt/phases/lowering.rs index ed50ed20db..992672846d 100644 --- a/crates/bolt/src/protocols/jolt/phases/lowering.rs +++ b/crates/bolt/src/protocols/jolt/phases/lowering.rs @@ -429,6 +429,33 @@ pub(super) fn lower_party_to_compute<'c>( insert_result_mapping(&mut value_map, op, operation, 0, 0)?; insert_result_mapping(&mut value_map, op, operation, 1, 1)?; } + "piop.sumcheck_output_value" => { + let operands = lowered_operands(op, &value_map, 0)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs(op, &["kind", "point_order"])?; + let operation = context.append_typed_op_with_owned_attrs( + &compute, + "compute.sumcheck_output_value", + Some(&symbol), + &attrs, + &operands, + &["!compute.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } + "piop.sumcheck_output_claim" => { + let operands = lowered_operands(op, &value_map, 0)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs(op, &["stage", "relation", "count", "local_values"])?; + let _operation = context.append_typed_op_with_owned_attrs( + &compute, + "compute.sumcheck_output_claim", + Some(&symbol), + &attrs, + &operands, + &[], + )?; + } "piop.opening_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; diff --git a/crates/bolt/src/protocols/jolt/phases/stage1.rs b/crates/bolt/src/protocols/jolt/phases/stage1.rs index 7501e62768..fd2f86c917 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage1.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage1.rs @@ -849,6 +849,33 @@ pub fn resolve_compute_kernels<'c>( insert_result_mapping(&mut value_map, op, operation, 0, 0)?; insert_result_mapping(&mut value_map, op, operation, 1, 1)?; } + "compute.sumcheck_output_value" => { + let operands = lowered_operands(op, &value_map, 0)?; + let attrs = copy_attrs(op, &["kind", "point_order"])?; + let symbol = string_attr(op, "sym_name")?; + let operation = context.append_typed_op_with_owned_attrs( + &kernelized, + "compute.sumcheck_output_value", + Some(&symbol), + &attrs, + &operands, + &["!compute.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } + "compute.sumcheck_output_claim" => { + let operands = lowered_operands(op, &value_map, 0)?; + let attrs = copy_attrs(op, &["stage", "relation", "count", "local_values"])?; + let symbol = string_attr(op, "sym_name")?; + let _operation = context.append_typed_op_with_owned_attrs( + &kernelized, + "compute.sumcheck_output_claim", + Some(&symbol), + &attrs, + &operands, + &[], + )?; + } "compute.opening_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let attrs = copy_attrs(op, &["oracle", "domain", "point_arity", "claim_kind"])?; diff --git a/crates/bolt/src/protocols/jolt/phases/stage3.rs b/crates/bolt/src/protocols/jolt/phases/stage3.rs index b0e3c1513d..92d28d951d 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage3.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage3.rs @@ -473,6 +473,33 @@ pub fn lower_stage3_to_compute<'c>( insert_result_mapping(&mut value_map, op, operation, 0, 0)?; insert_result_mapping(&mut value_map, op, operation, 1, 1)?; } + "piop.sumcheck_output_value" => { + let operands = lowered_operands(op, &value_map, 0)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs(op, &["kind", "point_order"])?; + let operation = context.append_typed_op_with_owned_attrs( + &compute, + "compute.sumcheck_output_value", + Some(&symbol), + &attrs, + &operands, + &["!compute.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } + "piop.sumcheck_output_claim" => { + let operands = lowered_operands(op, &value_map, 0)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs(op, &["stage", "relation", "count", "local_values"])?; + let _operation = context.append_typed_op_with_owned_attrs( + &compute, + "compute.sumcheck_output_claim", + Some(&symbol), + &attrs, + &operands, + &[], + )?; + } "piop.opening_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; @@ -805,6 +832,7 @@ fn append_stage_input<'c, 'a>( &["!poly.point", "!field.scalar", "!piop.opening_claim_type"], )?; Ok(Stage3OpeningInput { + point: result(op, 0, "piop.opening_input")?, eval: result(op, 1, "piop.opening_input")?, claim: result(op, 2, "piop.opening_input")?, }) @@ -1250,71 +1278,281 @@ fn append_stage3_batched_sumcheck<'c, 'a>( point, result_value, )?; - append_stage3_output_openings( + let output_evals = append_stage3_output_openings( context, module, - &[ - InstanceOutput { - prefix: "stage3.spartan_shift", - instance: shift, - outputs: &STAGE3_SHIFT_OUTPUTS, - degree_offset: 0, - }, - InstanceOutput { - prefix: "stage3.instruction_input", - instance: instruction, - outputs: &STAGE3_INSTRUCTION_INPUT_OUTPUTS, - degree_offset: STAGE3_SHIFT_OUTPUTS.len(), - }, - InstanceOutput { - prefix: "stage3.registers_claim_reduction", - instance: registers, - outputs: &STAGE3_REGISTER_INPUTS, - degree_offset: STAGE3_SHIFT_OUTPUTS.len() + STAGE3_INSTRUCTION_INPUT_OUTPUTS.len(), - }, - ], + Stage3Instances { + shift, + instruction, + registers, + }, params.log_t, )?; + append_stage3_output_claims( + context, + module, + Stage3OutputClaimInputs { + openings: inputs, + output_evals: &output_evals, + instances: Stage3Instances { + shift, + instruction, + registers, + }, + shift_gamma: spec.shift_gamma, + shift_gamma2, + shift_gamma3, + shift_gamma4, + field_one: one, + instruction_gamma: spec.instruction_gamma, + registers_gamma: spec.registers_gamma, + registers_gamma2, + }, + )?; Ok(state) } fn append_stage3_output_openings<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, - outputs: &[InstanceOutput<'c, 'a, '_>], + instances: Stage3Instances<'c, 'a>, point_arity: usize, -) -> Result<(), MlirError> { +) -> Result, MlirError> { let mut claims = Vec::new(); let mut claim_symbols = Vec::new(); - for output in outputs { - for (index, &oracle) in output.outputs.iter().enumerate() { - let symbol = format!("{}.opening.{oracle}", output.prefix); - let eval = append_sumcheck_eval( - context, - module, - &format!("{}.eval.{oracle}", output.prefix), - "stage3.sumcheck", - oracle, - output.degree_offset + index, - output.instance.1, - )?; - claim_symbols.push(symbol.clone()); - claims.push(append_opening_claim( - context, - module, - output.instance.0, - eval, - OpeningClaimSpec { - symbol: &symbol, - oracle, - domain: "jolt.trace_domain", - point_arity, - claim_kind: "virtual", - }, - )?); - } - } + let shift = Stage3ShiftOutputEvals { + unexpanded_pc: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.spartan_shift", + oracle: "UnexpandedPC", + index: 0, + degree_offset: 0, + instance: instances.shift, + point_arity, + }, + )?, + pc: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.spartan_shift", + oracle: "PC", + index: 1, + degree_offset: 0, + instance: instances.shift, + point_arity, + }, + )?, + op_flag_virtual_instruction: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.spartan_shift", + oracle: "OpFlagVirtualInstruction", + index: 2, + degree_offset: 0, + instance: instances.shift, + point_arity, + }, + )?, + op_flag_is_first_in_sequence: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.spartan_shift", + oracle: "OpFlagIsFirstInSequence", + index: 3, + degree_offset: 0, + instance: instances.shift, + point_arity, + }, + )?, + instruction_flag_is_noop: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.spartan_shift", + oracle: "InstructionFlagIsNoop", + index: 4, + degree_offset: 0, + instance: instances.shift, + point_arity, + }, + )?, + }; + + let instruction = Stage3InstructionInputOutputEvals { + left_operand_is_rs1_value: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.instruction_input", + oracle: "InstructionFlagLeftOperandIsRs1Value", + index: 0, + degree_offset: STAGE3_SHIFT_OUTPUTS.len(), + instance: instances.instruction, + point_arity, + }, + )?, + rs1_value: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.instruction_input", + oracle: "Rs1Value", + index: 1, + degree_offset: STAGE3_SHIFT_OUTPUTS.len(), + instance: instances.instruction, + point_arity, + }, + )?, + left_operand_is_pc: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.instruction_input", + oracle: "InstructionFlagLeftOperandIsPC", + index: 2, + degree_offset: STAGE3_SHIFT_OUTPUTS.len(), + instance: instances.instruction, + point_arity, + }, + )?, + unexpanded_pc: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.instruction_input", + oracle: "UnexpandedPC", + index: 3, + degree_offset: STAGE3_SHIFT_OUTPUTS.len(), + instance: instances.instruction, + point_arity, + }, + )?, + right_operand_is_rs2_value: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.instruction_input", + oracle: "InstructionFlagRightOperandIsRs2Value", + index: 4, + degree_offset: STAGE3_SHIFT_OUTPUTS.len(), + instance: instances.instruction, + point_arity, + }, + )?, + rs2_value: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.instruction_input", + oracle: "Rs2Value", + index: 5, + degree_offset: STAGE3_SHIFT_OUTPUTS.len(), + instance: instances.instruction, + point_arity, + }, + )?, + right_operand_is_imm: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.instruction_input", + oracle: "InstructionFlagRightOperandIsImm", + index: 6, + degree_offset: STAGE3_SHIFT_OUTPUTS.len(), + instance: instances.instruction, + point_arity, + }, + )?, + imm: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.instruction_input", + oracle: "Imm", + index: 7, + degree_offset: STAGE3_SHIFT_OUTPUTS.len(), + instance: instances.instruction, + point_arity, + }, + )?, + }; + + let registers = Stage3RegistersOutputEvals { + rd_write: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.registers_claim_reduction", + oracle: "RdWriteValue", + index: 0, + degree_offset: STAGE3_SHIFT_OUTPUTS.len() + STAGE3_INSTRUCTION_INPUT_OUTPUTS.len(), + instance: instances.registers, + point_arity, + }, + )?, + rs1: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.registers_claim_reduction", + oracle: "Rs1Value", + index: 1, + degree_offset: STAGE3_SHIFT_OUTPUTS.len() + STAGE3_INSTRUCTION_INPUT_OUTPUTS.len(), + instance: instances.registers, + point_arity, + }, + )?, + rs2: append_output_eval_claim( + context, + module, + &mut claims, + &mut claim_symbols, + OutputEvalClaimSpec { + prefix: "stage3.registers_claim_reduction", + oracle: "Rs2Value", + index: 2, + degree_offset: STAGE3_SHIFT_OUTPUTS.len() + STAGE3_INSTRUCTION_INPUT_OUTPUTS.len(), + instance: instances.registers, + point_arity, + }, + )?, + }; let claim_names = claim_symbols.iter().map(String::as_str).collect::>(); let _batch = context.append_typed_op( @@ -1331,6 +1569,368 @@ fn append_stage3_output_openings<'c, 'a>( &claims, &["!piop.opening_batch_type"], )?; + Ok(Stage3OutputEvals { + shift, + instruction, + registers, + }) +} + +fn append_output_eval_claim<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + claims: &mut Vec>, + claim_symbols: &mut Vec, + spec: OutputEvalClaimSpec<'c, 'a, '_>, +) -> Result, MlirError> { + let symbol = format!("{}.opening.{}", spec.prefix, spec.oracle); + let eval = append_sumcheck_eval( + context, + module, + &format!("{}.eval.{}", spec.prefix, spec.oracle), + "stage3.sumcheck", + spec.oracle, + spec.degree_offset + spec.index, + spec.instance.1, + )?; + claim_symbols.push(symbol.clone()); + claims.push(append_opening_claim( + context, + module, + spec.instance.0, + eval, + OpeningClaimSpec { + symbol: &symbol, + oracle: spec.oracle, + domain: "jolt.trace_domain", + point_arity: spec.point_arity, + claim_kind: "virtual", + }, + )?); + Ok(eval) +} + +fn append_stage3_output_claims<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + spec: Stage3OutputClaimInputs<'c, 'a, '_>, +) -> Result<(), MlirError> { + let shift_eq_next_pc = append_sumcheck_output_value( + context, + module, + OutputValueSpec { + symbol: "stage3.spartan_shift.output.eq.NextPC", + kind: "eq_plus_one", + point_order: "reverse", + }, + spec.instances.shift.0, + spec.openings.next_pc.point, + )?; + let shift_eq_next_is_noop = append_sumcheck_output_value( + context, + module, + OutputValueSpec { + symbol: "stage3.spartan_shift.output.eq.NextIsNoop", + kind: "eq_plus_one", + point_order: "reverse", + }, + spec.instances.shift.0, + spec.openings.product_next_is_noop.point, + )?; + let shift_term_pc = append_field_mul( + context, + module, + "stage3.spartan_shift.output.term.PC", + spec.shift_gamma, + spec.output_evals.shift.pc, + )?; + let shift_term_virtual = append_field_mul( + context, + module, + "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", + spec.shift_gamma2, + spec.output_evals.shift.op_flag_virtual_instruction, + )?; + let shift_term_first = append_field_mul( + context, + module, + "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", + spec.shift_gamma3, + spec.output_evals.shift.op_flag_is_first_in_sequence, + )?; + let shift_one_minus_noop = append_field_sub( + context, + module, + "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", + spec.field_one, + spec.output_evals.shift.instruction_flag_is_noop, + )?; + let shift_partial_pc = append_field_add( + context, + module, + "stage3.spartan_shift.output.partial.PC", + spec.output_evals.shift.unexpanded_pc, + shift_term_pc, + )?; + let shift_partial_virtual = append_field_add( + context, + module, + "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", + shift_partial_pc, + shift_term_virtual, + )?; + let shift_weighted_outer = append_field_add( + context, + module, + "stage3.spartan_shift.output.weighted_outer", + shift_partial_virtual, + shift_term_first, + )?; + let shift_outer = append_field_mul( + context, + module, + "stage3.spartan_shift.output.outer", + shift_eq_next_pc, + shift_weighted_outer, + )?; + let shift_noop_product = append_field_mul( + context, + module, + "stage3.spartan_shift.output.noop_product", + shift_eq_next_is_noop, + shift_one_minus_noop, + )?; + let shift_noop_term = append_field_mul( + context, + module, + "stage3.spartan_shift.output.noop_term", + spec.shift_gamma4, + shift_noop_product, + )?; + let shift_claim = append_field_add( + context, + module, + "stage3.spartan_shift.output.claim_expr", + shift_outer, + shift_noop_term, + )?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage3.spartan_shift.output.claim", + stage: "stage3", + relation: "jolt.stage3.spartan_shift", + }, + shift_claim, + &[ + ("stage3.spartan_shift.output.eq.NextPC", shift_eq_next_pc), + ( + "stage3.spartan_shift.output.eq.NextIsNoop", + shift_eq_next_is_noop, + ), + ], + )?; + + let instruction_eq_left = append_sumcheck_output_value( + context, + module, + OutputValueSpec { + symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", + kind: "eq_mle", + point_order: "reverse", + }, + spec.instances.instruction.0, + spec.openings.product_left_instruction_input.point, + )?; + let instruction_left_rs1 = append_field_mul( + context, + module, + "stage3.instruction_input.output.left.term.Rs1Value", + spec.output_evals.instruction.left_operand_is_rs1_value, + spec.output_evals.instruction.rs1_value, + )?; + let instruction_left_pc = append_field_mul( + context, + module, + "stage3.instruction_input.output.left.term.PC", + spec.output_evals.instruction.left_operand_is_pc, + spec.output_evals.instruction.unexpanded_pc, + )?; + let instruction_left = append_field_add( + context, + module, + "stage3.instruction_input.output.left", + instruction_left_rs1, + instruction_left_pc, + )?; + let instruction_right_rs2 = append_field_mul( + context, + module, + "stage3.instruction_input.output.right.term.Rs2Value", + spec.output_evals.instruction.right_operand_is_rs2_value, + spec.output_evals.instruction.rs2_value, + )?; + let instruction_right_imm = append_field_mul( + context, + module, + "stage3.instruction_input.output.right.term.Imm", + spec.output_evals.instruction.right_operand_is_imm, + spec.output_evals.instruction.imm, + )?; + let instruction_right = append_field_add( + context, + module, + "stage3.instruction_input.output.right", + instruction_right_rs2, + instruction_right_imm, + )?; + let instruction_left_weighted = append_field_mul( + context, + module, + "stage3.instruction_input.output.left_weighted", + spec.instruction_gamma, + instruction_left, + )?; + let instruction_weighted_inputs = append_field_add( + context, + module, + "stage3.instruction_input.output.weighted_inputs", + instruction_right, + instruction_left_weighted, + )?; + let instruction_claim = append_field_mul( + context, + module, + "stage3.instruction_input.output.claim_expr", + instruction_eq_left, + instruction_weighted_inputs, + )?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage3.instruction_input.output.claim", + stage: "stage3", + relation: "jolt.stage3.instruction_input", + }, + instruction_claim, + &[( + "stage3.instruction_input.output.eq.LeftInstructionInput", + instruction_eq_left, + )], + )?; + + let registers_eq_rd_write = append_sumcheck_output_value( + context, + module, + OutputValueSpec { + symbol: "stage3.registers.output.eq.RdWriteValue", + kind: "eq_mle", + point_order: "reverse", + }, + spec.instances.registers.0, + spec.openings.rd_write_value.point, + )?; + let registers_rs1 = append_field_mul( + context, + module, + "stage3.registers.output.term.Rs1Value", + spec.registers_gamma, + spec.output_evals.registers.rs1, + )?; + let registers_rs2 = append_field_mul( + context, + module, + "stage3.registers.output.term.Rs2Value", + spec.registers_gamma2, + spec.output_evals.registers.rs2, + )?; + let registers_partial = append_field_add( + context, + module, + "stage3.registers.output.partial.RdWriteValueRs1Value", + spec.output_evals.registers.rd_write, + registers_rs1, + )?; + let registers_weighted_values = append_field_add( + context, + module, + "stage3.registers.output.weighted_register_values", + registers_partial, + registers_rs2, + )?; + let registers_claim = append_field_mul( + context, + module, + "stage3.registers.output.claim_expr", + registers_eq_rd_write, + registers_weighted_values, + )?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage3.registers.output.claim", + stage: "stage3", + relation: "jolt.stage3.registers_claim_reduction", + }, + registers_claim, + &[( + "stage3.registers.output.eq.RdWriteValue", + registers_eq_rd_write, + )], + ) +} + +fn append_sumcheck_output_value<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + spec: OutputValueSpec<'_>, + local_point: Value<'c, 'a>, + opening_point: Value<'c, 'a>, +) -> Result, MlirError> { + let op = context.append_typed_op( + module, + "piop.sumcheck_output_value", + Some(spec.symbol), + &[ + ("kind", &format!("\"{}\"", spec.kind)), + ("point_order", &format!("\"{}\"", spec.point_order)), + ], + &[local_point, opening_point], + &["!field.scalar"], + )?; + first_result(op, "piop.sumcheck_output_value") +} + +fn append_sumcheck_output_claim<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + spec: OutputClaimSpec<'_>, + claim_value: Value<'c, 'a>, + local_values: &[(&str, Value<'c, 'a>)], +) -> Result<(), MlirError> { + let mut operands = Vec::with_capacity(local_values.len() + 1); + operands.push(claim_value); + operands.extend(local_values.iter().map(|(_, value)| *value)); + let local_value_symbols = local_values + .iter() + .map(|(symbol, _)| *symbol) + .collect::>(); + let _op = context.append_typed_op( + module, + "piop.sumcheck_output_claim", + Some(spec.symbol), + &[ + ("stage", &format!("@{}", spec.stage)), + ("relation", &format!("@{}", spec.relation)), + ("count", &int_attr(local_values.len())), + ("local_values", &symbol_array_attr(&local_value_symbols)), + ], + &operands, + &[], + )?; Ok(()) } @@ -1655,6 +2255,7 @@ fn schema_error(message: impl Into) -> MlirError { #[derive(Clone, Copy)] struct Stage3OpeningInput<'c, 'a> { + point: Value<'c, 'a>, eval: Value<'c, 'a>, claim: Value<'c, 'a>, } @@ -1754,9 +2355,75 @@ struct OpeningClaimSpec<'a> { claim_kind: &'a str, } -struct InstanceOutput<'c, 'a, 'b> { +#[derive(Clone, Copy)] +struct Stage3Instances<'c, 'a> { + shift: (Value<'c, 'a>, Value<'c, 'a>), + instruction: (Value<'c, 'a>, Value<'c, 'a>), + registers: (Value<'c, 'a>, Value<'c, 'a>), +} + +struct OutputEvalClaimSpec<'c, 'a, 'b> { prefix: &'b str, - instance: (Value<'c, 'a>, Value<'c, 'a>), - outputs: &'b [&'b str], + oracle: &'b str, + index: usize, degree_offset: usize, + instance: (Value<'c, 'a>, Value<'c, 'a>), + point_arity: usize, +} + +struct Stage3OutputEvals<'c, 'a> { + shift: Stage3ShiftOutputEvals<'c, 'a>, + instruction: Stage3InstructionInputOutputEvals<'c, 'a>, + registers: Stage3RegistersOutputEvals<'c, 'a>, +} + +struct Stage3ShiftOutputEvals<'c, 'a> { + unexpanded_pc: Value<'c, 'a>, + pc: Value<'c, 'a>, + op_flag_virtual_instruction: Value<'c, 'a>, + op_flag_is_first_in_sequence: Value<'c, 'a>, + instruction_flag_is_noop: Value<'c, 'a>, +} + +struct Stage3InstructionInputOutputEvals<'c, 'a> { + left_operand_is_rs1_value: Value<'c, 'a>, + rs1_value: Value<'c, 'a>, + left_operand_is_pc: Value<'c, 'a>, + unexpanded_pc: Value<'c, 'a>, + right_operand_is_rs2_value: Value<'c, 'a>, + rs2_value: Value<'c, 'a>, + right_operand_is_imm: Value<'c, 'a>, + imm: Value<'c, 'a>, +} + +struct Stage3RegistersOutputEvals<'c, 'a> { + rd_write: Value<'c, 'a>, + rs1: Value<'c, 'a>, + rs2: Value<'c, 'a>, +} + +struct Stage3OutputClaimInputs<'c, 'a, 'b> { + openings: &'b Stage3OpeningInputs<'c, 'a>, + output_evals: &'b Stage3OutputEvals<'c, 'a>, + instances: Stage3Instances<'c, 'a>, + shift_gamma: Value<'c, 'a>, + shift_gamma2: Value<'c, 'a>, + shift_gamma3: Value<'c, 'a>, + shift_gamma4: Value<'c, 'a>, + field_one: Value<'c, 'a>, + instruction_gamma: Value<'c, 'a>, + registers_gamma: Value<'c, 'a>, + registers_gamma2: Value<'c, 'a>, +} + +struct OutputValueSpec<'a> { + symbol: &'a str, + kind: &'a str, + point_order: &'a str, +} + +struct OutputClaimSpec<'a> { + symbol: &'a str, + stage: &'a str, + relation: &'a str, } diff --git a/crates/bolt/src/schema.rs b/crates/bolt/src/schema.rs index 46e963c4e7..7304983dab 100644 --- a/crates/bolt/src/schema.rs +++ b/crates/bolt/src/schema.rs @@ -362,6 +362,19 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( )?; require_shape(operation, 2, 2) } + "piop.sumcheck_output_value" => { + require_attrs(operation, &["sym_name", "kind", "point_order"])?; + require_shape(operation, 2, 1)?; + require_sumcheck_output_value(operation) + } + "piop.sumcheck_output_claim" => { + require_attrs( + operation, + &["sym_name", "stage", "relation", "count", "local_values"], + )?; + require_min_shape(operation, 1, 0)?; + require_sumcheck_output_claim(operation) + } "piop.opening_claim" => { require_attrs( operation, @@ -706,6 +719,19 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( )?; require_shape(operation, 2, 2) } + "compute.sumcheck_output_value" => { + require_attrs(operation, &["sym_name", "kind", "point_order"])?; + require_shape(operation, 2, 1)?; + require_sumcheck_output_value(operation) + } + "compute.sumcheck_output_claim" => { + require_attrs( + operation, + &["sym_name", "stage", "relation", "count", "local_values"], + )?; + require_min_shape(operation, 1, 0)?; + require_sumcheck_output_claim(operation) + } "compute.opening_claim" => { require_attrs( operation, @@ -1033,6 +1059,19 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( )?; require_shape(operation, 2, 2) } + "cpu.sumcheck_output_value" => { + require_attrs(operation, &["sym_name", "kind", "point_order"])?; + require_shape(operation, 2, 1)?; + require_sumcheck_output_value(operation) + } + "cpu.sumcheck_output_claim" => { + require_attrs( + operation, + &["sym_name", "stage", "relation", "count", "local_values"], + )?; + require_min_shape(operation, 1, 0)?; + require_sumcheck_output_claim(operation) + } "cpu.opening_claim" => { require_attrs( operation, @@ -1158,6 +1197,54 @@ fn require_opening_claim_equality(operation: OperationRef<'_, '_>) -> Result<(), Ok(()) } +fn require_sumcheck_output_value(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> { + let kind = string_attr(operation, "kind")?; + if !matches!(kind.as_str(), "eq_mle" | "eq_plus_one") { + return Err(SchemaError::new(format!( + "{} attr `kind` has unsupported output value kind `{kind}`", + operation_name(operation) + ))); + } + let point_order = string_attr(operation, "point_order")?; + if !matches!(point_order.as_str(), "as_is" | "reverse") { + return Err(SchemaError::new(format!( + "{} attr `point_order` has unsupported output point order `{point_order}`", + operation_name(operation) + ))); + } + Ok(()) +} + +fn require_sumcheck_output_claim(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> { + let count = int_attr(operation, "count")?; + let local_values = symbol_array_attr(operation, "local_values")?; + if local_values.len() != count { + return Err(SchemaError::new(format!( + "{} attr `local_values` length {} does not match count {count}", + operation_name(operation), + local_values.len() + ))); + } + let dynamic_count = operation.operand_count().saturating_sub(1); + if dynamic_count != count { + return Err(SchemaError::new(format!( + "{} attr `count` expected {dynamic_count}, got {count}", + operation_name(operation) + ))); + } + for (index, expected) in local_values.iter().enumerate() { + let operand_index = index + 1; + let actual = operand_owner_symbol(operation, operand_index)?; + if &actual != expected { + return Err(SchemaError::new(format!( + "{} operand {operand_index} expected @{expected}, got @{actual}", + operation_name(operation) + ))); + } + } + Ok(()) +} + fn opening_claim_metadata( equality_op: OperationRef<'_, '_>, operand_index: usize, From 4422964b986a8f7456067266ccaf7f4cd2a1f9a8 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 11:32:42 -0600 Subject: [PATCH 022/171] refactor(bolt): compact stage3 output formulas Add a reusable compiler-side field formula builder for protocol-owned verifier value plans, and use it to express Stage 3 output-claim formulas as declarative formula data while preserving emitted MLIR symbols and operation order. Replace the output-claim scratch overlay with a named map-backed scratch store so verifier runtime evaluation no longer depends on cloned value stores as formula plans grow. --- crates/bolt-verifier-runtime/src/lib.rs | 53 +-- .../protocols/jolt/phases/field_formula.rs | 127 ++++++ crates/bolt/src/protocols/jolt/phases/mod.rs | 1 + .../bolt/src/protocols/jolt/phases/stage3.rs | 407 ++++++++++-------- 4 files changed, 387 insertions(+), 201 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/phases/field_formula.rs diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 37d2e26018..95340129c0 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -3,6 +3,7 @@ reason = "generated verifier helpers mirror staged protocol ABIs" )] +use std::collections::BTreeMap; use std::fmt; use std::marker::PhantomData; @@ -1116,9 +1117,9 @@ pub fn evaluate_sumcheck_output_claim( evals: &[StageNamedEval], local_point: &[Fr], ) -> Result { - let mut scratch = Vec::new(); + let mut scratch = ScratchScalars::default(); for eval in evals { - insert_scratch_scalar(&mut scratch, eval.name, eval.value); + scratch.insert(eval.name, eval.value); } for local_value in plan.local_values { if local_value.local_point_source != instance_symbol { @@ -1142,54 +1143,54 @@ pub fn evaluate_sumcheck_output_claim( EqPlusOnePolynomial::::new(opening_point.to_vec()).evaluate(&ordered_point) } }; - insert_scratch_scalar(&mut scratch, local_value.symbol, value); + scratch.insert(local_value.symbol, value); } evaluate_available_field_exprs_with_scratch(field_exprs, store, &mut scratch)?; - scratch_scalar_or(store, &scratch, plan.claim_value).ok_or(RuntimePlanError::MissingValue { - symbol: plan.claim_value, - }) + scratch + .scalar_or(store, plan.claim_value) + .ok_or(RuntimePlanError::MissingValue { + symbol: plan.claim_value, + }) } -fn insert_scratch_scalar(scratch: &mut Vec<(&'static str, Fr)>, symbol: &'static str, value: Fr) { - if let Some((_, existing)) = scratch.iter_mut().find(|(name, _)| *name == symbol) { - *existing = value; - } else { - scratch.push((symbol, value)); - } +#[derive(Default)] +struct ScratchScalars { + values: BTreeMap<&'static str, Fr>, } -fn scratch_scalar_or( - store: &ValueStore, - scratch: &[(&'static str, Fr)], - symbol: &'static str, -) -> Option { - scratch - .iter() - .find(|(name, _)| *name == symbol) - .map(|(_, value)| *value) - .or_else(|| store.try_scalar(symbol)) +impl ScratchScalars { + fn insert(&mut self, symbol: &'static str, value: Fr) { + let _ = self.values.insert(symbol, value); + } + + fn scalar_or(&self, store: &ValueStore, symbol: &'static str) -> Option { + self.values + .get(symbol) + .copied() + .or_else(|| store.try_scalar(symbol)) + } } fn evaluate_available_field_exprs_with_scratch( field_exprs: &[FieldExprPlan], store: &ValueStore, - scratch: &mut Vec<(&'static str, Fr)>, + scratch: &mut ScratchScalars, ) -> Result<(), RuntimePlanError> { loop { let mut progress = 0usize; for expr in field_exprs { - if scratch_scalar_or(store, scratch, expr.symbol).is_some() { + if scratch.scalar_or(store, expr.symbol).is_some() { continue; } let Some(operands) = expr .operands .iter() - .map(|operand| scratch_scalar_or(store, scratch, operand)) + .map(|operand| scratch.scalar_or(store, operand)) .collect::>>() else { continue; }; - insert_scratch_scalar(scratch, expr.symbol, evaluate_field_expr(expr, &operands)?); + scratch.insert(expr.symbol, evaluate_field_expr(expr, &operands)?); progress += 1; } if progress == 0 { diff --git a/crates/bolt/src/protocols/jolt/phases/field_formula.rs b/crates/bolt/src/protocols/jolt/phases/field_formula.rs new file mode 100644 index 0000000000..b33a6d1e3d --- /dev/null +++ b/crates/bolt/src/protocols/jolt/phases/field_formula.rs @@ -0,0 +1,127 @@ +use std::collections::BTreeMap; + +use melior::ir::Value; + +use crate::ir::{BoltModule, Protocol}; +use crate::mlir::{MeliorContext, MlirError}; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum FieldBinaryOp { + Add, + Sub, + Mul, +} + +impl FieldBinaryOp { + fn op_name(self) -> &'static str { + match self { + Self::Add => "field.add", + Self::Sub => "field.sub", + Self::Mul => "field.mul", + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct FieldBinaryFormula { + pub(crate) symbol: &'static str, + op: FieldBinaryOp, + lhs: &'static str, + rhs: &'static str, +} + +impl FieldBinaryFormula { + pub(crate) const fn add(symbol: &'static str, lhs: &'static str, rhs: &'static str) -> Self { + Self { + symbol, + op: FieldBinaryOp::Add, + lhs, + rhs, + } + } + + pub(crate) const fn sub(symbol: &'static str, lhs: &'static str, rhs: &'static str) -> Self { + Self { + symbol, + op: FieldBinaryOp::Sub, + lhs, + rhs, + } + } + + pub(crate) const fn mul(symbol: &'static str, lhs: &'static str, rhs: &'static str) -> Self { + Self { + symbol, + op: FieldBinaryOp::Mul, + lhs, + rhs, + } + } +} + +pub(crate) struct FieldFormulaBuilder<'c, 'a> { + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + values: BTreeMap<&'static str, Value<'c, 'a>>, +} + +impl<'c, 'a> FieldFormulaBuilder<'c, 'a> { + pub(crate) fn new(context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>) -> Self { + Self { + context, + module, + values: BTreeMap::new(), + } + } + + pub(crate) fn bind(&mut self, symbol: &'static str, value: Value<'c, 'a>) { + let _ = self.values.insert(symbol, value); + } + + pub(crate) fn bind_all(&mut self, values: &[(&'static str, Value<'c, 'a>)]) { + for (symbol, value) in values { + self.bind(symbol, *value); + } + } + + pub(crate) fn append_all(&mut self, formulas: &[FieldBinaryFormula]) -> Result<(), MlirError> { + for formula in formulas { + let _ = self.append(*formula)?; + } + Ok(()) + } + + pub(crate) fn value(&self, symbol: &'static str) -> Result, MlirError> { + self.values + .get(symbol) + .copied() + .ok_or_else(|| MlirError::Schema { + message: format!("field formula value @{symbol} is missing"), + }) + } + + fn append(&mut self, formula: FieldBinaryFormula) -> Result, MlirError> { + let lhs = self.value(formula.lhs)?; + let rhs = self.value(formula.rhs)?; + let op = self.context.append_typed_op( + self.module, + formula.op.op_name(), + Some(formula.symbol), + &[], + &[lhs, rhs], + &["!field.scalar"], + )?; + let value: Value<'c, 'a> = op + .result(0) + .map_err(|_| MlirError::Schema { + message: format!( + "{} @{} did not produce a field value", + formula.op.op_name(), + formula.symbol + ), + })? + .into(); + self.bind(formula.symbol, value); + Ok(value) + } +} diff --git a/crates/bolt/src/protocols/jolt/phases/mod.rs b/crates/bolt/src/protocols/jolt/phases/mod.rs index 19f9646db3..e976bc9396 100644 --- a/crates/bolt/src/protocols/jolt/phases/mod.rs +++ b/crates/bolt/src/protocols/jolt/phases/mod.rs @@ -1,3 +1,4 @@ +mod field_formula; mod lowering; pub mod commitment; diff --git a/crates/bolt/src/protocols/jolt/phases/stage3.rs b/crates/bolt/src/protocols/jolt/phases/stage3.rs index 92d28d951d..35d335cb2a 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage3.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage3.rs @@ -14,6 +14,7 @@ use crate::schema::{ use super::super::oracles; use super::super::params::JoltProtocolParams; +use super::field_formula::{FieldBinaryFormula, FieldFormulaBuilder}; use super::lowering::{ copy_attrs, field_lowering_attrs as field_compute_attrs, string_attr, transcript_squeeze_compute_result_types, transcript_squeeze_protocol_result_type, @@ -49,6 +50,140 @@ const STAGE3_INSTRUCTION_INPUT_OUTPUTS: [&str; 8] = [ ]; const STAGE3_REGISTER_INPUTS: [&str; 3] = ["RdWriteValue", "Rs1Value", "Rs2Value"]; +const STAGE3_SHIFT_OUTPUT_FORMULAS: [FieldBinaryFormula; 11] = [ + FieldBinaryFormula::mul( + "stage3.spartan_shift.output.term.PC", + "stage3.spartan_shift.gamma", + "stage3.spartan_shift.eval.PC", + ), + FieldBinaryFormula::mul( + "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", + "stage3.spartan_shift.gamma2", + "stage3.spartan_shift.eval.OpFlagVirtualInstruction", + ), + FieldBinaryFormula::mul( + "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", + "stage3.spartan_shift.gamma3", + "stage3.spartan_shift.eval.OpFlagIsFirstInSequence", + ), + FieldBinaryFormula::sub( + "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", + "stage3.field.one", + "stage3.spartan_shift.eval.InstructionFlagIsNoop", + ), + FieldBinaryFormula::add( + "stage3.spartan_shift.output.partial.PC", + "stage3.spartan_shift.eval.UnexpandedPC", + "stage3.spartan_shift.output.term.PC", + ), + FieldBinaryFormula::add( + "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", + "stage3.spartan_shift.output.partial.PC", + "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", + ), + FieldBinaryFormula::add( + "stage3.spartan_shift.output.weighted_outer", + "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", + "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", + ), + FieldBinaryFormula::mul( + "stage3.spartan_shift.output.outer", + "stage3.spartan_shift.output.eq.NextPC", + "stage3.spartan_shift.output.weighted_outer", + ), + FieldBinaryFormula::mul( + "stage3.spartan_shift.output.noop_product", + "stage3.spartan_shift.output.eq.NextIsNoop", + "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", + ), + FieldBinaryFormula::mul( + "stage3.spartan_shift.output.noop_term", + "stage3.spartan_shift.gamma4", + "stage3.spartan_shift.output.noop_product", + ), + FieldBinaryFormula::add( + "stage3.spartan_shift.output.claim_expr", + "stage3.spartan_shift.output.outer", + "stage3.spartan_shift.output.noop_term", + ), +]; + +const STAGE3_INSTRUCTION_OUTPUT_FORMULAS: [FieldBinaryFormula; 9] = [ + FieldBinaryFormula::mul( + "stage3.instruction_input.output.left.term.Rs1Value", + "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value", + "stage3.instruction_input.eval.Rs1Value", + ), + FieldBinaryFormula::mul( + "stage3.instruction_input.output.left.term.PC", + "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC", + "stage3.instruction_input.eval.UnexpandedPC", + ), + FieldBinaryFormula::add( + "stage3.instruction_input.output.left", + "stage3.instruction_input.output.left.term.Rs1Value", + "stage3.instruction_input.output.left.term.PC", + ), + FieldBinaryFormula::mul( + "stage3.instruction_input.output.right.term.Rs2Value", + "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value", + "stage3.instruction_input.eval.Rs2Value", + ), + FieldBinaryFormula::mul( + "stage3.instruction_input.output.right.term.Imm", + "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", + "stage3.instruction_input.eval.Imm", + ), + FieldBinaryFormula::add( + "stage3.instruction_input.output.right", + "stage3.instruction_input.output.right.term.Rs2Value", + "stage3.instruction_input.output.right.term.Imm", + ), + FieldBinaryFormula::mul( + "stage3.instruction_input.output.left_weighted", + "stage3.instruction_input.gamma", + "stage3.instruction_input.output.left", + ), + FieldBinaryFormula::add( + "stage3.instruction_input.output.weighted_inputs", + "stage3.instruction_input.output.right", + "stage3.instruction_input.output.left_weighted", + ), + FieldBinaryFormula::mul( + "stage3.instruction_input.output.claim_expr", + "stage3.instruction_input.output.eq.LeftInstructionInput", + "stage3.instruction_input.output.weighted_inputs", + ), +]; + +const STAGE3_REGISTERS_OUTPUT_FORMULAS: [FieldBinaryFormula; 5] = [ + FieldBinaryFormula::mul( + "stage3.registers.output.term.Rs1Value", + "stage3.registers.gamma", + "stage3.registers_claim_reduction.eval.Rs1Value", + ), + FieldBinaryFormula::mul( + "stage3.registers.output.term.Rs2Value", + "stage3.registers.gamma2", + "stage3.registers_claim_reduction.eval.Rs2Value", + ), + FieldBinaryFormula::add( + "stage3.registers.output.partial.RdWriteValueRs1Value", + "stage3.registers_claim_reduction.eval.RdWriteValue", + "stage3.registers.output.term.Rs1Value", + ), + FieldBinaryFormula::add( + "stage3.registers.output.weighted_register_values", + "stage3.registers.output.partial.RdWriteValueRs1Value", + "stage3.registers.output.term.Rs2Value", + ), + FieldBinaryFormula::mul( + "stage3.registers.output.claim_expr", + "stage3.registers.output.eq.RdWriteValue", + "stage3.registers.output.weighted_register_values", + ), +]; + pub fn build_stage3_protocol<'c>( context: &'c MeliorContext, params: &JoltProtocolParams, @@ -1637,83 +1772,38 @@ fn append_stage3_output_claims<'c, 'a>( spec.instances.shift.0, spec.openings.product_next_is_noop.point, )?; - let shift_term_pc = append_field_mul( - context, - module, - "stage3.spartan_shift.output.term.PC", - spec.shift_gamma, - spec.output_evals.shift.pc, - )?; - let shift_term_virtual = append_field_mul( - context, - module, - "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", - spec.shift_gamma2, - spec.output_evals.shift.op_flag_virtual_instruction, - )?; - let shift_term_first = append_field_mul( - context, - module, - "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", - spec.shift_gamma3, - spec.output_evals.shift.op_flag_is_first_in_sequence, - )?; - let shift_one_minus_noop = append_field_sub( - context, - module, - "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", - spec.field_one, - spec.output_evals.shift.instruction_flag_is_noop, - )?; - let shift_partial_pc = append_field_add( - context, - module, - "stage3.spartan_shift.output.partial.PC", - spec.output_evals.shift.unexpanded_pc, - shift_term_pc, - )?; - let shift_partial_virtual = append_field_add( - context, - module, - "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", - shift_partial_pc, - shift_term_virtual, - )?; - let shift_weighted_outer = append_field_add( - context, - module, - "stage3.spartan_shift.output.weighted_outer", - shift_partial_virtual, - shift_term_first, - )?; - let shift_outer = append_field_mul( - context, - module, - "stage3.spartan_shift.output.outer", - shift_eq_next_pc, - shift_weighted_outer, - )?; - let shift_noop_product = append_field_mul( - context, - module, - "stage3.spartan_shift.output.noop_product", - shift_eq_next_is_noop, - shift_one_minus_noop, - )?; - let shift_noop_term = append_field_mul( - context, - module, - "stage3.spartan_shift.output.noop_term", - spec.shift_gamma4, - shift_noop_product, - )?; - let shift_claim = append_field_add( - context, - module, - "stage3.spartan_shift.output.claim_expr", - shift_outer, - shift_noop_term, - )?; + let mut formula = FieldFormulaBuilder::new(context, module); + formula.bind_all(&[ + ("stage3.spartan_shift.gamma", spec.shift_gamma), + ("stage3.spartan_shift.gamma2", spec.shift_gamma2), + ("stage3.spartan_shift.gamma3", spec.shift_gamma3), + ("stage3.spartan_shift.gamma4", spec.shift_gamma4), + ("stage3.field.one", spec.field_one), + ( + "stage3.spartan_shift.eval.UnexpandedPC", + spec.output_evals.shift.unexpanded_pc, + ), + ("stage3.spartan_shift.eval.PC", spec.output_evals.shift.pc), + ( + "stage3.spartan_shift.eval.OpFlagVirtualInstruction", + spec.output_evals.shift.op_flag_virtual_instruction, + ), + ( + "stage3.spartan_shift.eval.OpFlagIsFirstInSequence", + spec.output_evals.shift.op_flag_is_first_in_sequence, + ), + ( + "stage3.spartan_shift.eval.InstructionFlagIsNoop", + spec.output_evals.shift.instruction_flag_is_noop, + ), + ("stage3.spartan_shift.output.eq.NextPC", shift_eq_next_pc), + ( + "stage3.spartan_shift.output.eq.NextIsNoop", + shift_eq_next_is_noop, + ), + ]); + formula.append_all(&STAGE3_SHIFT_OUTPUT_FORMULAS)?; + let shift_claim = formula.value("stage3.spartan_shift.output.claim_expr")?; append_sumcheck_output_claim( context, module, @@ -1743,69 +1833,48 @@ fn append_stage3_output_claims<'c, 'a>( spec.instances.instruction.0, spec.openings.product_left_instruction_input.point, )?; - let instruction_left_rs1 = append_field_mul( - context, - module, - "stage3.instruction_input.output.left.term.Rs1Value", - spec.output_evals.instruction.left_operand_is_rs1_value, - spec.output_evals.instruction.rs1_value, - )?; - let instruction_left_pc = append_field_mul( - context, - module, - "stage3.instruction_input.output.left.term.PC", - spec.output_evals.instruction.left_operand_is_pc, - spec.output_evals.instruction.unexpanded_pc, - )?; - let instruction_left = append_field_add( - context, - module, - "stage3.instruction_input.output.left", - instruction_left_rs1, - instruction_left_pc, - )?; - let instruction_right_rs2 = append_field_mul( - context, - module, - "stage3.instruction_input.output.right.term.Rs2Value", - spec.output_evals.instruction.right_operand_is_rs2_value, - spec.output_evals.instruction.rs2_value, - )?; - let instruction_right_imm = append_field_mul( - context, - module, - "stage3.instruction_input.output.right.term.Imm", - spec.output_evals.instruction.right_operand_is_imm, - spec.output_evals.instruction.imm, - )?; - let instruction_right = append_field_add( - context, - module, - "stage3.instruction_input.output.right", - instruction_right_rs2, - instruction_right_imm, - )?; - let instruction_left_weighted = append_field_mul( - context, - module, - "stage3.instruction_input.output.left_weighted", - spec.instruction_gamma, - instruction_left, - )?; - let instruction_weighted_inputs = append_field_add( - context, - module, - "stage3.instruction_input.output.weighted_inputs", - instruction_right, - instruction_left_weighted, - )?; - let instruction_claim = append_field_mul( - context, - module, - "stage3.instruction_input.output.claim_expr", - instruction_eq_left, - instruction_weighted_inputs, - )?; + let mut formula = FieldFormulaBuilder::new(context, module); + formula.bind_all(&[ + ("stage3.instruction_input.gamma", spec.instruction_gamma), + ( + "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value", + spec.output_evals.instruction.left_operand_is_rs1_value, + ), + ( + "stage3.instruction_input.eval.Rs1Value", + spec.output_evals.instruction.rs1_value, + ), + ( + "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC", + spec.output_evals.instruction.left_operand_is_pc, + ), + ( + "stage3.instruction_input.eval.UnexpandedPC", + spec.output_evals.instruction.unexpanded_pc, + ), + ( + "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value", + spec.output_evals.instruction.right_operand_is_rs2_value, + ), + ( + "stage3.instruction_input.eval.Rs2Value", + spec.output_evals.instruction.rs2_value, + ), + ( + "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", + spec.output_evals.instruction.right_operand_is_imm, + ), + ( + "stage3.instruction_input.eval.Imm", + spec.output_evals.instruction.imm, + ), + ( + "stage3.instruction_input.output.eq.LeftInstructionInput", + instruction_eq_left, + ), + ]); + formula.append_all(&STAGE3_INSTRUCTION_OUTPUT_FORMULAS)?; + let instruction_claim = formula.value("stage3.instruction_input.output.claim_expr")?; append_sumcheck_output_claim( context, module, @@ -1832,41 +1901,29 @@ fn append_stage3_output_claims<'c, 'a>( spec.instances.registers.0, spec.openings.rd_write_value.point, )?; - let registers_rs1 = append_field_mul( - context, - module, - "stage3.registers.output.term.Rs1Value", - spec.registers_gamma, - spec.output_evals.registers.rs1, - )?; - let registers_rs2 = append_field_mul( - context, - module, - "stage3.registers.output.term.Rs2Value", - spec.registers_gamma2, - spec.output_evals.registers.rs2, - )?; - let registers_partial = append_field_add( - context, - module, - "stage3.registers.output.partial.RdWriteValueRs1Value", - spec.output_evals.registers.rd_write, - registers_rs1, - )?; - let registers_weighted_values = append_field_add( - context, - module, - "stage3.registers.output.weighted_register_values", - registers_partial, - registers_rs2, - )?; - let registers_claim = append_field_mul( - context, - module, - "stage3.registers.output.claim_expr", - registers_eq_rd_write, - registers_weighted_values, - )?; + let mut formula = FieldFormulaBuilder::new(context, module); + formula.bind_all(&[ + ("stage3.registers.gamma", spec.registers_gamma), + ("stage3.registers.gamma2", spec.registers_gamma2), + ( + "stage3.registers_claim_reduction.eval.RdWriteValue", + spec.output_evals.registers.rd_write, + ), + ( + "stage3.registers_claim_reduction.eval.Rs1Value", + spec.output_evals.registers.rs1, + ), + ( + "stage3.registers_claim_reduction.eval.Rs2Value", + spec.output_evals.registers.rs2, + ), + ( + "stage3.registers.output.eq.RdWriteValue", + registers_eq_rd_write, + ), + ]); + formula.append_all(&STAGE3_REGISTERS_OUTPUT_FORMULAS)?; + let registers_claim = formula.value("stage3.registers.output.claim_expr")?; append_sumcheck_output_claim( context, module, From 18f67b529120dc23471132f9de88e83824fed0c7 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 12:24:36 -0600 Subject: [PATCH 023/171] refactor(bolt): clarify field formula step names Rename the field formula helper types so they describe formula steps and operators rather than binary arity. This avoids implying binary-field semantics in the Stage 3 formula authoring path. --- .../protocols/jolt/phases/field_formula.rs | 20 +++---- .../bolt/src/protocols/jolt/phases/stage3.rs | 58 +++++++++---------- 2 files changed, 39 insertions(+), 39 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/phases/field_formula.rs b/crates/bolt/src/protocols/jolt/phases/field_formula.rs index b33a6d1e3d..cc3a59e59c 100644 --- a/crates/bolt/src/protocols/jolt/phases/field_formula.rs +++ b/crates/bolt/src/protocols/jolt/phases/field_formula.rs @@ -6,13 +6,13 @@ use crate::ir::{BoltModule, Protocol}; use crate::mlir::{MeliorContext, MlirError}; #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) enum FieldBinaryOp { +pub(crate) enum FieldOp { Add, Sub, Mul, } -impl FieldBinaryOp { +impl FieldOp { fn op_name(self) -> &'static str { match self { Self::Add => "field.add", @@ -23,18 +23,18 @@ impl FieldBinaryOp { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) struct FieldBinaryFormula { +pub(crate) struct FieldFormulaStep { pub(crate) symbol: &'static str, - op: FieldBinaryOp, + op: FieldOp, lhs: &'static str, rhs: &'static str, } -impl FieldBinaryFormula { +impl FieldFormulaStep { pub(crate) const fn add(symbol: &'static str, lhs: &'static str, rhs: &'static str) -> Self { Self { symbol, - op: FieldBinaryOp::Add, + op: FieldOp::Add, lhs, rhs, } @@ -43,7 +43,7 @@ impl FieldBinaryFormula { pub(crate) const fn sub(symbol: &'static str, lhs: &'static str, rhs: &'static str) -> Self { Self { symbol, - op: FieldBinaryOp::Sub, + op: FieldOp::Sub, lhs, rhs, } @@ -52,7 +52,7 @@ impl FieldBinaryFormula { pub(crate) const fn mul(symbol: &'static str, lhs: &'static str, rhs: &'static str) -> Self { Self { symbol, - op: FieldBinaryOp::Mul, + op: FieldOp::Mul, lhs, rhs, } @@ -84,7 +84,7 @@ impl<'c, 'a> FieldFormulaBuilder<'c, 'a> { } } - pub(crate) fn append_all(&mut self, formulas: &[FieldBinaryFormula]) -> Result<(), MlirError> { + pub(crate) fn append_all(&mut self, formulas: &[FieldFormulaStep]) -> Result<(), MlirError> { for formula in formulas { let _ = self.append(*formula)?; } @@ -100,7 +100,7 @@ impl<'c, 'a> FieldFormulaBuilder<'c, 'a> { }) } - fn append(&mut self, formula: FieldBinaryFormula) -> Result, MlirError> { + fn append(&mut self, formula: FieldFormulaStep) -> Result, MlirError> { let lhs = self.value(formula.lhs)?; let rhs = self.value(formula.rhs)?; let op = self.context.append_typed_op( diff --git a/crates/bolt/src/protocols/jolt/phases/stage3.rs b/crates/bolt/src/protocols/jolt/phases/stage3.rs index 35d335cb2a..7a02710549 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage3.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage3.rs @@ -14,7 +14,7 @@ use crate::schema::{ use super::super::oracles; use super::super::params::JoltProtocolParams; -use super::field_formula::{FieldBinaryFormula, FieldFormulaBuilder}; +use super::field_formula::{FieldFormulaBuilder, FieldFormulaStep}; use super::lowering::{ copy_attrs, field_lowering_attrs as field_compute_attrs, string_attr, transcript_squeeze_compute_result_types, transcript_squeeze_protocol_result_type, @@ -50,134 +50,134 @@ const STAGE3_INSTRUCTION_INPUT_OUTPUTS: [&str; 8] = [ ]; const STAGE3_REGISTER_INPUTS: [&str; 3] = ["RdWriteValue", "Rs1Value", "Rs2Value"]; -const STAGE3_SHIFT_OUTPUT_FORMULAS: [FieldBinaryFormula; 11] = [ - FieldBinaryFormula::mul( +const STAGE3_SHIFT_OUTPUT_FORMULAS: [FieldFormulaStep; 11] = [ + FieldFormulaStep::mul( "stage3.spartan_shift.output.term.PC", "stage3.spartan_shift.gamma", "stage3.spartan_shift.eval.PC", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", "stage3.spartan_shift.gamma2", "stage3.spartan_shift.eval.OpFlagVirtualInstruction", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", "stage3.spartan_shift.gamma3", "stage3.spartan_shift.eval.OpFlagIsFirstInSequence", ), - FieldBinaryFormula::sub( + FieldFormulaStep::sub( "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", "stage3.field.one", "stage3.spartan_shift.eval.InstructionFlagIsNoop", ), - FieldBinaryFormula::add( + FieldFormulaStep::add( "stage3.spartan_shift.output.partial.PC", "stage3.spartan_shift.eval.UnexpandedPC", "stage3.spartan_shift.output.term.PC", ), - FieldBinaryFormula::add( + FieldFormulaStep::add( "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", "stage3.spartan_shift.output.partial.PC", "stage3.spartan_shift.output.term.OpFlagVirtualInstruction", ), - FieldBinaryFormula::add( + FieldFormulaStep::add( "stage3.spartan_shift.output.weighted_outer", "stage3.spartan_shift.output.partial.OpFlagVirtualInstruction", "stage3.spartan_shift.output.term.OpFlagIsFirstInSequence", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.spartan_shift.output.outer", "stage3.spartan_shift.output.eq.NextPC", "stage3.spartan_shift.output.weighted_outer", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.spartan_shift.output.noop_product", "stage3.spartan_shift.output.eq.NextIsNoop", "stage3.spartan_shift.output.one_minus.InstructionFlagIsNoop", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.spartan_shift.output.noop_term", "stage3.spartan_shift.gamma4", "stage3.spartan_shift.output.noop_product", ), - FieldBinaryFormula::add( + FieldFormulaStep::add( "stage3.spartan_shift.output.claim_expr", "stage3.spartan_shift.output.outer", "stage3.spartan_shift.output.noop_term", ), ]; -const STAGE3_INSTRUCTION_OUTPUT_FORMULAS: [FieldBinaryFormula; 9] = [ - FieldBinaryFormula::mul( +const STAGE3_INSTRUCTION_OUTPUT_FORMULAS: [FieldFormulaStep; 9] = [ + FieldFormulaStep::mul( "stage3.instruction_input.output.left.term.Rs1Value", "stage3.instruction_input.eval.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.eval.Rs1Value", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.instruction_input.output.left.term.PC", "stage3.instruction_input.eval.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.eval.UnexpandedPC", ), - FieldBinaryFormula::add( + FieldFormulaStep::add( "stage3.instruction_input.output.left", "stage3.instruction_input.output.left.term.Rs1Value", "stage3.instruction_input.output.left.term.PC", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.instruction_input.output.right.term.Rs2Value", "stage3.instruction_input.eval.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.eval.Rs2Value", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.instruction_input.output.right.term.Imm", "stage3.instruction_input.eval.InstructionFlagRightOperandIsImm", "stage3.instruction_input.eval.Imm", ), - FieldBinaryFormula::add( + FieldFormulaStep::add( "stage3.instruction_input.output.right", "stage3.instruction_input.output.right.term.Rs2Value", "stage3.instruction_input.output.right.term.Imm", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.instruction_input.output.left_weighted", "stage3.instruction_input.gamma", "stage3.instruction_input.output.left", ), - FieldBinaryFormula::add( + FieldFormulaStep::add( "stage3.instruction_input.output.weighted_inputs", "stage3.instruction_input.output.right", "stage3.instruction_input.output.left_weighted", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.instruction_input.output.claim_expr", "stage3.instruction_input.output.eq.LeftInstructionInput", "stage3.instruction_input.output.weighted_inputs", ), ]; -const STAGE3_REGISTERS_OUTPUT_FORMULAS: [FieldBinaryFormula; 5] = [ - FieldBinaryFormula::mul( +const STAGE3_REGISTERS_OUTPUT_FORMULAS: [FieldFormulaStep; 5] = [ + FieldFormulaStep::mul( "stage3.registers.output.term.Rs1Value", "stage3.registers.gamma", "stage3.registers_claim_reduction.eval.Rs1Value", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.registers.output.term.Rs2Value", "stage3.registers.gamma2", "stage3.registers_claim_reduction.eval.Rs2Value", ), - FieldBinaryFormula::add( + FieldFormulaStep::add( "stage3.registers.output.partial.RdWriteValueRs1Value", "stage3.registers_claim_reduction.eval.RdWriteValue", "stage3.registers.output.term.Rs1Value", ), - FieldBinaryFormula::add( + FieldFormulaStep::add( "stage3.registers.output.weighted_register_values", "stage3.registers.output.partial.RdWriteValueRs1Value", "stage3.registers.output.term.Rs2Value", ), - FieldBinaryFormula::mul( + FieldFormulaStep::mul( "stage3.registers.output.claim_expr", "stage3.registers.output.eq.RdWriteValue", "stage3.registers.output.weighted_register_values", From 467cea1f445e6139300ac1d7da93b40480d73353 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 13:15:04 -0600 Subject: [PATCH 024/171] refactor(bolt): lift stage4 output claims Introduce typed sumcheck output point plans with explicit segment, length, and order semantics, plus LT output value evaluation for Stage 4 RAM val checks. Move Stage 4 register read/write and RAM val expected output claims into protocol-owned verifier plan data, cut the new shape through IRDL, schema, Rust emission, runtime, and equivalence adapters, and keep proof serialization unchanged. --- crates/bolt-verifier-runtime/src/lib.rs | 117 ++++- crates/bolt/irdl/compute.mlir | 14 +- crates/bolt/irdl/cpu.mlir | 14 +- crates/bolt/irdl/piop.mlir | 14 +- .../src/protocols/jolt/emit/rust/stage3.rs | 124 ++++- .../src/protocols/jolt/emit/rust/stage4.rs | 485 ++++++++++++++---- .../src/protocols/jolt/emit/rust/stage5.rs | 6 + .../src/protocols/jolt/phases/commitment.rs | 13 +- .../src/protocols/jolt/phases/lowering.rs | 13 +- crates/bolt/src/protocols/jolt/phases/mod.rs | 1 + .../bolt/src/protocols/jolt/phases/stage1.rs | 13 +- .../bolt/src/protocols/jolt/phases/stage3.rs | 92 +--- .../bolt/src/protocols/jolt/phases/stage4.rs | 226 +++++++- .../protocols/jolt/phases/sumcheck_output.rs | 148 ++++++ crates/bolt/src/schema.rs | 57 +- crates/jolt-equivalence/src/plan_adapters.rs | 68 ++- .../src/plan_adapters/generated_stage4.rs | 4 +- .../src/plan_adapters/generated_stage5.rs | 3 +- crates/jolt-verifier/src/stages/stage3.rs | 11 +- crates/jolt-verifier/src/stages/stage4.rs | 143 ++---- crates/jolt-verifier/src/stages/stage5.rs | 1 + 21 files changed, 1237 insertions(+), 330 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 95340129c0..fe63322e56 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -318,19 +318,41 @@ pub enum SumcheckOutputPointOrder { Reverse, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SumcheckOutputPointSegment { + Full, + Prefix, + Suffix, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SumcheckOutputPointLength { + Full, + LocalPoint, + OpeningPoint, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct SumcheckOutputPointPlan { + pub source: &'static str, + pub segment: SumcheckOutputPointSegment, + pub length: SumcheckOutputPointLength, + pub order: SumcheckOutputPointOrder, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum SumcheckOutputValueKind { EqMle, EqPlusOne, + Lt, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct SumcheckOutputValuePlan { pub symbol: &'static str, pub kind: SumcheckOutputValueKind, - pub point_order: SumcheckOutputPointOrder, - pub local_point_source: &'static str, - pub opening_point_source: &'static str, + pub local_point: SumcheckOutputPointPlan, + pub opening_point: SumcheckOutputPointPlan, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -448,6 +470,7 @@ pub struct StageProgramPlanNoPointZeros { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], + pub output_claims: &'static [SumcheckOutputClaimPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], pub opening_claims: &'static [OpeningClaimPlan], @@ -1122,25 +1145,36 @@ pub fn evaluate_sumcheck_output_claim( scratch.insert(eval.name, eval.value); } for local_value in plan.local_values { - if local_value.local_point_source != instance_symbol { + if local_value.local_point.source != instance_symbol { return Err(RuntimePlanError::InvalidProof { driver: instance_symbol, reason: "sumcheck output value source mismatch", }); } - let opening_point = store.point_or(local_value.opening_point_source, |symbol| { + let opening_point = store.point_or(local_value.opening_point.source, |symbol| { RuntimePlanError::MissingValue { symbol } })?; - let ordered_point = match local_value.point_order { - SumcheckOutputPointOrder::AsIs => local_point.to_vec(), - SumcheckOutputPointOrder::Reverse => reverse_slice(local_point), - }; + let local_output_point = evaluate_sumcheck_output_point( + local_value.local_point, + local_point, + local_point, + opening_point, + )?; + let opening_output_point = evaluate_sumcheck_output_point( + local_value.opening_point, + opening_point, + local_point, + opening_point, + )?; let value = match local_value.kind { SumcheckOutputValueKind::EqMle => { - EqPolynomial::::mle(&ordered_point, opening_point) + EqPolynomial::::mle(&local_output_point, &opening_output_point) } SumcheckOutputValueKind::EqPlusOne => { - EqPlusOnePolynomial::::new(opening_point.to_vec()).evaluate(&ordered_point) + EqPlusOnePolynomial::::new(opening_output_point).evaluate(&local_output_point) + } + SumcheckOutputValueKind::Lt => { + lt_polynomial_eval(&local_output_point, &opening_output_point)? } }; scratch.insert(local_value.symbol, value); @@ -1153,6 +1187,67 @@ pub fn evaluate_sumcheck_output_claim( }) } +fn evaluate_sumcheck_output_point( + plan: SumcheckOutputPointPlan, + raw_point: &[Fr], + local_point: &[Fr], + opening_point: &[Fr], +) -> Result, RuntimePlanError> { + if matches!(plan.segment, SumcheckOutputPointSegment::Full) + && !matches!(plan.length, SumcheckOutputPointLength::Full) + { + return Err(RuntimePlanError::InvalidProof { + driver: plan.source, + reason: "full output point segment requires full length", + }); + } + let length = match plan.length { + SumcheckOutputPointLength::Full => raw_point.len(), + SumcheckOutputPointLength::LocalPoint => local_point.len(), + SumcheckOutputPointLength::OpeningPoint => opening_point.len(), + }; + let segment = match plan.segment { + SumcheckOutputPointSegment::Full => raw_point, + SumcheckOutputPointSegment::Prefix => raw_point + .get(..length) + .filter(|prefix| prefix.len() == length) + .ok_or(RuntimePlanError::InvalidInputLength { + input: plan.source, + expected: length, + actual: raw_point.len(), + })?, + SumcheckOutputPointSegment::Suffix => raw_point + .get(raw_point.len().saturating_sub(length)..) + .filter(|suffix| suffix.len() == length) + .ok_or(RuntimePlanError::InvalidInputLength { + input: plan.source, + expected: length, + actual: raw_point.len(), + })?, + }; + Ok(match plan.order { + SumcheckOutputPointOrder::AsIs => segment.to_vec(), + SumcheckOutputPointOrder::Reverse => reverse_slice(segment), + }) +} + +fn lt_polynomial_eval(x: &[Fr], y: &[Fr]) -> Result { + if x.len() != y.len() { + return Err(RuntimePlanError::InvalidInputLength { + input: "sumcheck_output.lt", + expected: x.len(), + actual: y.len(), + }); + } + let mut lt_eval = Fr::from_u64(0); + let mut eq_term = Fr::from_u64(1); + for (x_i, y_i) in x.iter().zip(y) { + lt_eval += (Fr::from_u64(1) - *x_i) * *y_i * eq_term; + eq_term *= Fr::from_u64(1) - *x_i - *y_i + *x_i * *y_i + *x_i * *y_i; + } + Ok(lt_eval) +} + #[derive(Default)] struct ScratchScalars { values: BTreeMap<&'static str, Fr>, diff --git a/crates/bolt/irdl/compute.mlir b/crates/bolt/irdl/compute.mlir index 7f2626d77d..78d6433815 100644 --- a/crates/bolt/irdl/compute.mlir +++ b/crates/bolt/irdl/compute.mlir @@ -675,11 +675,21 @@ irdl.dialect @compute { %value = irdl.parametric @compute::@field_value<> %sym = irdl.any %kind = irdl.any - %point_order = irdl.any + %local_point_segment = irdl.any + %local_point_length = irdl.any + %local_point_order = irdl.any + %opening_point_segment = irdl.any + %opening_point_length = irdl.any + %opening_point_order = irdl.any irdl.attributes { "sym_name" = %sym, "kind" = %kind, - "point_order" = %point_order + "local_point_segment" = %local_point_segment, + "local_point_length" = %local_point_length, + "local_point_order" = %local_point_order, + "opening_point_segment" = %opening_point_segment, + "opening_point_length" = %opening_point_length, + "opening_point_order" = %opening_point_order } irdl.operands(local_point: %point, opening_point: %point) irdl.results(value: %value) diff --git a/crates/bolt/irdl/cpu.mlir b/crates/bolt/irdl/cpu.mlir index d115906834..1352a50a58 100644 --- a/crates/bolt/irdl/cpu.mlir +++ b/crates/bolt/irdl/cpu.mlir @@ -605,11 +605,21 @@ irdl.dialect @cpu { %value = irdl.parametric @cpu::@field_value<> %sym = irdl.any %kind = irdl.any - %point_order = irdl.any + %local_point_segment = irdl.any + %local_point_length = irdl.any + %local_point_order = irdl.any + %opening_point_segment = irdl.any + %opening_point_length = irdl.any + %opening_point_order = irdl.any irdl.attributes { "sym_name" = %sym, "kind" = %kind, - "point_order" = %point_order + "local_point_segment" = %local_point_segment, + "local_point_length" = %local_point_length, + "local_point_order" = %local_point_order, + "opening_point_segment" = %opening_point_segment, + "opening_point_length" = %opening_point_length, + "opening_point_order" = %opening_point_order } irdl.operands(local_point: %point, opening_point: %point) irdl.results(value: %value) diff --git a/crates/bolt/irdl/piop.mlir b/crates/bolt/irdl/piop.mlir index d70915e52f..d45339ec42 100644 --- a/crates/bolt/irdl/piop.mlir +++ b/crates/bolt/irdl/piop.mlir @@ -223,11 +223,21 @@ irdl.dialect @piop { %value = irdl.parametric @field::@scalar<> %sym = irdl.any %kind = irdl.any - %point_order = irdl.any + %local_point_segment = irdl.any + %local_point_length = irdl.any + %local_point_order = irdl.any + %opening_point_segment = irdl.any + %opening_point_length = irdl.any + %opening_point_order = irdl.any irdl.attributes { "sym_name" = %sym, "kind" = %kind, - "point_order" = %point_order + "local_point_segment" = %local_point_segment, + "local_point_length" = %local_point_length, + "local_point_order" = %local_point_order, + "opening_point_segment" = %opening_point_segment, + "opening_point_length" = %opening_point_length, + "opening_point_order" = %opening_point_order } irdl.operands(local_point: %point, opening_point: %point) irdl.results(value: %value) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 2481c5a4fe..69a9a7c5df 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -147,13 +147,20 @@ pub struct Stage3SumcheckInstanceResultPlan { pub degree: usize, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage3SumcheckOutputPointPlan { + pub source: String, + pub segment: String, + pub length: String, + pub order: String, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage3SumcheckOutputValuePlan { pub symbol: String, pub kind: String, - pub point_order: String, - pub local_point_source: String, - pub opening_point_source: String, + pub local_point: Stage3SumcheckOutputPointPlan, + pub opening_point: Stage3SumcheckOutputPointPlan, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -477,9 +484,18 @@ impl Stage3CpuProgram { output_values.push(Stage3SumcheckOutputValuePlan { symbol: string_attr(op, "sym_name")?, kind: string_attr(op, "kind")?, - point_order: string_attr(op, "point_order")?, - local_point_source: operand_symbol(op, 0)?, - opening_point_source: operand_symbol(op, 1)?, + local_point: Stage3SumcheckOutputPointPlan { + source: operand_symbol(op, 0)?, + segment: string_attr(op, "local_point_segment")?, + length: string_attr(op, "local_point_length")?, + order: string_attr(op, "local_point_order")?, + }, + opening_point: Stage3SumcheckOutputPointPlan { + source: operand_symbol(op, 1)?, + segment: string_attr(op, "opening_point_segment")?, + length: string_attr(op, "opening_point_length")?, + order: string_attr(op, "opening_point_order")?, + }, }); } "cpu.sumcheck_output_claim" => { @@ -865,30 +881,26 @@ impl Stage3CpuProgram { let field_values = self.field_value_symbols(); let point_values = self.point_value_symbols(); for local_value in &self.output_values { - if !point_values.contains(&local_value.local_point_source) { + if !point_values.contains(&local_value.local_point.source) { return Err(EmitError::new(format!( "stage3 output value @{} references missing local point @{}", - local_value.symbol, local_value.local_point_source + local_value.symbol, local_value.local_point.source ))); } - if !point_values.contains(&local_value.opening_point_source) { + if !point_values.contains(&local_value.opening_point.source) { return Err(EmitError::new(format!( "stage3 output value @{} references missing opening point @{}", - local_value.symbol, local_value.opening_point_source + local_value.symbol, local_value.opening_point.source ))); } - if !matches!(local_value.kind.as_str(), "eq_mle" | "eq_plus_one") { + if !matches!(local_value.kind.as_str(), "eq_mle" | "eq_plus_one" | "lt") { return Err(EmitError::new(format!( "stage3 output value @{} has unsupported kind `{}`", local_value.symbol, local_value.kind ))); } - if !matches!(local_value.point_order.as_str(), "as_is" | "reverse") { - return Err(EmitError::new(format!( - "stage3 output value @{} has unsupported point order `{}`", - local_value.symbol, local_value.point_order - ))); - } + verify_output_point_plan("stage3", local_value, &local_value.local_point)?; + verify_output_point_plan("stage3", local_value, &local_value.opening_point)?; } for claim in &self.output_claims { if !relations.contains(&claim.relation) { @@ -1117,7 +1129,10 @@ pub use bolt_verifier_runtime::{ ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, + SumcheckOutputPointLength as Stage3SumcheckOutputPointLength, SumcheckOutputPointOrder as Stage3SumcheckOutputPointOrder, + SumcheckOutputPointPlan as Stage3SumcheckOutputPointPlan, + SumcheckOutputPointSegment as Stage3SumcheckOutputPointSegment, SumcheckOutputValueKind as Stage3SumcheckOutputValueKind, TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, @@ -1678,12 +1693,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); .iter() .map(|value| { Ok(format!( - " Stage3SumcheckOutputValuePlan {{ symbol: {}, kind: {}, point_order: {}, local_point_source: {}, opening_point_source: {} }},", + " Stage3SumcheckOutputValuePlan {{ symbol: {}, kind: {}, local_point: {}, opening_point: {} }},", rust_str(&value.symbol), stage3_output_value_kind_expr(&value.kind)?, - stage3_output_point_order_expr(&value.point_order)?, - rust_str(&value.local_point_source), - rust_str(&value.opening_point_source) + stage3_output_point_expr(&value.local_point)?, + stage3_output_point_expr(&value.opening_point)?, )) }) .collect::, EmitError>>()? @@ -2262,22 +2276,84 @@ fn field_expr_dependency_closure<'a>( visited } +fn verify_output_point_plan( + stage: &str, + local_value: &Stage3SumcheckOutputValuePlan, + point: &Stage3SumcheckOutputPointPlan, +) -> Result<(), EmitError> { + if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { + return Err(EmitError::new(format!( + "{stage} output value @{} has unsupported point segment `{}`", + local_value.symbol, point.segment + ))); + } + if !matches!( + point.length.as_str(), + "full" | "local_point" | "opening_point" + ) { + return Err(EmitError::new(format!( + "{stage} output value @{} has unsupported point length `{}`", + local_value.symbol, point.length + ))); + } + if !matches!(point.order.as_str(), "as_is" | "reverse") { + return Err(EmitError::new(format!( + "{stage} output value @{} has unsupported point order `{}`", + local_value.symbol, point.order + ))); + } + Ok(()) +} + fn stage3_output_value_kind_expr(kind: &str) -> Result<&'static str, EmitError> { match kind { "eq_mle" => Ok("Stage3SumcheckOutputValueKind::EqMle"), "eq_plus_one" => Ok("Stage3SumcheckOutputValueKind::EqPlusOne"), + "lt" => Ok("Stage3SumcheckOutputValueKind::Lt"), _ => Err(EmitError::new(format!( "unsupported stage3 output value kind `{kind}`" ))), } } -fn stage3_output_point_order_expr(point_order: &str) -> Result<&'static str, EmitError> { - match point_order { +fn stage3_output_point_expr(point: &Stage3SumcheckOutputPointPlan) -> Result { + Ok(format!( + "Stage3SumcheckOutputPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", + rust_str(&point.source), + stage3_output_point_segment_expr(&point.segment)?, + stage3_output_point_length_expr(&point.length)?, + stage3_output_point_order_expr(&point.order)?, + )) +} + +fn stage3_output_point_segment_expr(segment: &str) -> Result<&'static str, EmitError> { + match segment { + "full" => Ok("Stage3SumcheckOutputPointSegment::Full"), + "prefix" => Ok("Stage3SumcheckOutputPointSegment::Prefix"), + "suffix" => Ok("Stage3SumcheckOutputPointSegment::Suffix"), + _ => Err(EmitError::new(format!( + "unsupported stage3 output point segment `{segment}`" + ))), + } +} + +fn stage3_output_point_length_expr(length: &str) -> Result<&'static str, EmitError> { + match length { + "full" => Ok("Stage3SumcheckOutputPointLength::Full"), + "local_point" => Ok("Stage3SumcheckOutputPointLength::LocalPoint"), + "opening_point" => Ok("Stage3SumcheckOutputPointLength::OpeningPoint"), + _ => Err(EmitError::new(format!( + "unsupported stage3 output point length `{length}`" + ))), + } +} + +fn stage3_output_point_order_expr(order: &str) -> Result<&'static str, EmitError> { + match order { "as_is" => Ok("Stage3SumcheckOutputPointOrder::AsIs"), "reverse" => Ok("Stage3SumcheckOutputPointOrder::Reverse"), _ => Err(EmitError::new(format!( - "unsupported stage3 output point order `{point_order}`" + "unsupported stage3 output point order `{order}`" ))), } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 3be7cf9aab..ef72386101 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -29,6 +29,8 @@ pub struct Stage4CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, + pub output_values: Vec, + pub output_claims: Vec, pub point_slices: Vec, pub point_concats: Vec, pub opening_claims: Vec, @@ -167,6 +169,37 @@ pub struct Stage4SumcheckEvalPlan { pub oracle: String, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage4SumcheckOutputPointPlan { + pub source: String, + pub segment: String, + pub length: String, + pub order: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage4SumcheckOutputValuePlan { + pub symbol: String, + pub kind: String, + pub local_point: Stage4SumcheckOutputPointPlan, + pub opening_point: Stage4SumcheckOutputPointPlan, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage4SumcheckOutputClaimPlan { + pub relation: String, + pub local_values: Vec, + pub claim_value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct Stage4SumcheckOutputClaimAst { + relation: String, + local_values: Vec, + local_value_operands: Vec, + claim_value: String, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage4PointSlicePlan { pub symbol: String, @@ -245,6 +278,8 @@ impl Stage4CpuProgram { let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); + let mut output_values = Vec::new(); + let mut output_claim_asts = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); let mut opening_claims = Vec::new(); @@ -456,6 +491,32 @@ impl Stage4CpuProgram { oracle: symbol_attr(op, "oracle")?, }); } + "cpu.sumcheck_output_value" => { + output_values.push(Stage4SumcheckOutputValuePlan { + symbol: string_attr(op, "sym_name")?, + kind: string_attr(op, "kind")?, + local_point: Stage4SumcheckOutputPointPlan { + source: operand_symbol(op, 0)?, + segment: string_attr(op, "local_point_segment")?, + length: string_attr(op, "local_point_length")?, + order: string_attr(op, "local_point_order")?, + }, + opening_point: Stage4SumcheckOutputPointPlan { + source: operand_symbol(op, 1)?, + segment: string_attr(op, "opening_point_segment")?, + length: string_attr(op, "opening_point_length")?, + order: string_attr(op, "opening_point_order")?, + }, + }); + } + "cpu.sumcheck_output_claim" => { + output_claim_asts.push(Stage4SumcheckOutputClaimAst { + relation: symbol_attr(op, "relation")?, + claim_value: operand_symbol(op, 0)?, + local_values: symbol_array_attr(op, "local_values")?, + local_value_operands: operand_symbols(op, 1)?, + }); + } "cpu.point_slice" => { point_slices.push(Stage4PointSlicePlan { symbol: string_attr(op, "sym_name")?, @@ -507,11 +568,21 @@ impl Stage4CpuProgram { } } + let role = module + .role() + .ok_or_else(|| EmitError::new("missing cpu party role"))?; + if role == Role::Prover { + prune_prover_output_field_exprs(&mut field_exprs, &claims, &output_claim_asts); + } + let output_claims = if role == Role::Verifier { + resolve_stage4_output_claims(&output_values, output_claim_asts)? + } else { + Vec::new() + }; + Ok(Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, - role: module - .role() - .ok_or_else(|| EmitError::new("missing cpu party role"))?, + role, steps, transcript_squeezes, transcript_absorb_bytes, @@ -524,6 +595,8 @@ impl Stage4CpuProgram { drivers, instance_results, evals, + output_values, + output_claims, point_slices, point_concats, opening_claims, @@ -546,6 +619,9 @@ impl Stage4CpuProgram { } Role::Verifier => self.verify_verifier_driver_bindings()?, } + if self.role == Role::Verifier { + self.verify_output_claims()?; + } self.verify_opening_flow() } @@ -621,6 +697,9 @@ impl Stage4CpuProgram { .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), )); + values.extend(symbols( + self.output_values.iter().map(|value| &value.symbol), + )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); values @@ -798,6 +877,64 @@ impl Stage4CpuProgram { Ok(()) } + fn verify_output_claims(&self) -> Result<(), EmitError> { + let relations = symbols( + self.instance_results + .iter() + .map(|instance| &instance.relation), + ); + let field_values = self.field_value_symbols(); + let mut point_values = symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + ); + point_values.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_values.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + for local_value in &self.output_values { + if !point_values.contains(&local_value.local_point.source) { + return Err(EmitError::new(format!( + "stage4 output value @{} references missing local point @{}", + local_value.symbol, local_value.local_point.source + ))); + } + if !point_values.contains(&local_value.opening_point.source) { + return Err(EmitError::new(format!( + "stage4 output value @{} references missing opening point @{}", + local_value.symbol, local_value.opening_point.source + ))); + } + if !matches!(local_value.kind.as_str(), "eq_mle" | "eq_plus_one" | "lt") { + return Err(EmitError::new(format!( + "stage4 output value @{} has unsupported kind `{}`", + local_value.symbol, local_value.kind + ))); + } + verify_output_point_plan("stage4", local_value, &local_value.local_point)?; + verify_output_point_plan("stage4", local_value, &local_value.opening_point)?; + } + for claim in &self.output_claims { + if !relations.contains(&claim.relation) { + return Err(EmitError::new(format!( + "stage4 output claim references missing relation @{}", + claim.relation + ))); + } + if !field_values.contains(&claim.claim_value) { + return Err(EmitError::new(format!( + "stage4 output claim for @{} uses missing claim value @{}", + claim.relation, claim.claim_value + ))); + } + } + Ok(()) + } + fn verify_opening_flow(&self) -> Result<(), EmitError> { let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); point_sources.extend(symbols( @@ -962,10 +1099,8 @@ impl Stage4CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ - use super::jolt_relations::lt_polynomial_eval;\n\ + "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ use jolt_field::{Field, Fr};\n\ - use jolt_poly::EqPolynomial;\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" } @@ -1186,6 +1321,8 @@ pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZe pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage4SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage4SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage4SumcheckOutputValuePlan = bolt_verifier_runtime::SumcheckOutputValuePlan; pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind; pub use bolt_verifier_runtime::{ @@ -1201,6 +1338,11 @@ pub use bolt_verifier_runtime::{ ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, SumcheckBatchPlan as Stage4SumcheckBatchPlan, SumcheckEvalPlan as Stage4SumcheckEvalPlan, + SumcheckOutputPointLength as Stage4SumcheckOutputPointLength, + SumcheckOutputPointOrder as Stage4SumcheckOutputPointOrder, + SumcheckOutputPointPlan as Stage4SumcheckOutputPointPlan, + SumcheckOutputPointSegment as Stage4SumcheckOutputPointSegment, + SumcheckOutputValueKind as Stage4SumcheckOutputValueKind, TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage4TranscriptSqueezeKind, TranscriptSqueezePlan as Stage4TranscriptSqueezePlan, @@ -1241,6 +1383,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); + if self.role == Role::Verifier { + source.push_str(&self.emit_verifier_output_claim_constants()?); + } + let output_claims_field = if self.role == Role::Verifier { + " output_claims: STAGE4_SUMCHECK_OUTPUT_CLAIMS,\n" + } else { + "" + }; push_format( &mut source, format_args!( @@ -1259,6 +1409,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); \x20 drivers: STAGE4_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE4_SUMCHECK_EVALS,\n\ + {output_claims_field}\ \x20 point_slices: STAGE4_POINT_SLICES,\n\ \x20 point_concats: STAGE4_POINT_CONCATS,\n\ \x20 opening_claims: STAGE4_OPENING_CLAIMS,\n\ @@ -1731,6 +1882,47 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); format!("pub const STAGE4_SUMCHECK_EVALS: &[Stage4SumcheckEvalPlan] = &[\n{evals}\n];\n\n") } + fn emit_verifier_output_claim_constants(&self) -> Result { + let mut source = String::new(); + let mut claims = Vec::new(); + for (index, claim) in self.output_claims.iter().enumerate() { + let values_name = format!("STAGE4_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES"); + let values = claim + .local_values + .iter() + .map(|value| { + Ok(format!( + " Stage4SumcheckOutputValuePlan {{ symbol: {}, kind: {}, local_point: {}, opening_point: {} }},", + rust_str(&value.symbol), + stage4_output_value_kind_expr(&value.kind)?, + stage4_output_point_expr(&value.local_point)?, + stage4_output_point_expr(&value.opening_point)?, + )) + }) + .collect::, EmitError>>()? + .join("\n"); + push_format( + &mut source, + format_args!( + "pub const {values_name}: &[Stage4SumcheckOutputValuePlan] = &[\n{values}\n];\n\n" + ), + ); + claims.push(format!( + " Stage4SumcheckOutputClaimPlan {{ relation: {}, local_values: {values_name}, claim_value: {} }},", + super::plan_tokens::role_relation_kind_expr("Stage4", &self.role, &claim.relation)?, + rust_str(&claim.claim_value) + )); + } + let claims = claims.join("\n"); + push_format( + &mut source, + format_args!( + "pub const STAGE4_SUMCHECK_OUTPUT_CLAIMS: &[Stage4SumcheckOutputClaimPlan] = &[\n{claims}\n];\n\n" + ), + ); + Ok(source) + } + fn emit_point_slice_constants(&self) -> String { let slices = self .point_slices @@ -2176,86 +2368,26 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let Some(relation) = claim.relation else { - return Err(VerifyStage4Error::InvalidProof { - driver: driver.symbol, - reason: "missing claim relation", - }); - }; - let value = match relation { - Stage4RelationKind::Stage4RegistersReadWrite => { - expected_registers_read_write(store, evals, local_point)? - } - Stage4RelationKind::Stage4RamValCheck => { - expected_ram_val_check(store, evals, local_point)? - } - relation => return Err(VerifyStage4Error::UnsupportedRelation { relation }), - }; + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage4Error::UnsupportedRelation { + relation: instance.relation, + })?; + let value = bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )?; expected += *coefficient * value; } Ok(expected) } -fn expected_registers_read_write( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage4NamedEval], - local_point: &[Fr], -) -> Result { - let trace_point = bolt_verifier_runtime::store_point(store, "stage4.input.stage3.registers.RdWriteValue")?; - let r_cycle = normalize_stage4_registers_rw_cycle_point( - local_point, - trace_point.len(), - "stage4.registers_read_write.instance", - )?; - let eq_eval = EqPolynomial::::mle(&r_cycle, trace_point); - let registers_val = eval_by_name( - evals, - "stage4.registers_read_write.eval.RegistersVal", - )?; - let rs1_ra = eval_by_name(evals, "stage4.registers_read_write.eval.Rs1Ra")?; - let rs2_ra = eval_by_name(evals, "stage4.registers_read_write.eval.Rs2Ra")?; - let rd_wa = eval_by_name(evals, "stage4.registers_read_write.eval.RdWa")?; - let rd_inc = eval_by_name(evals, "stage4.registers_read_write.eval.RdInc")?; - let gamma = bolt_verifier_runtime::store_scalar(store, "stage4.registers_read_write.gamma")?; - Ok(eq_eval - * (rd_wa * (registers_val + rd_inc) - + gamma * (rs1_ra * registers_val + gamma * rs2_ra * registers_val))) -} - -fn expected_ram_val_check( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage4NamedEval], - local_point: &[Fr], -) -> Result { - let ram_val_point = bolt_verifier_runtime::store_point(store, "stage4.input.stage2.RamVal")?; - let r_cycle_prime = reverse_slice(local_point); - let r_cycle = suffix_point( - ram_val_point, - r_cycle_prime.len(), - "stage4.input.stage2.RamVal", - )?; - let lt_eval = lt_polynomial_eval(&r_cycle_prime, r_cycle); - let gamma = bolt_verifier_runtime::store_scalar(store, "stage4.ram_val_check.gamma")?; - let ram_ra = eval_by_name(evals, "stage4.ram_val_check.eval.RamRa")?; - let ram_inc = eval_by_name(evals, "stage4.ram_val_check.eval.RamInc")?; - Ok(ram_inc * ram_ra * (lt_eval + gamma)) -} - -fn suffix_point<'a>( - point: &'a [Fr], - length: usize, - input: &'static str, -) -> Result<&'a [Fr], VerifyStage4Error> { - point - .get(point.len().saturating_sub(length)..) - .filter(|suffix| suffix.len() == length) - .ok_or(VerifyStage4Error::InvalidInputLength { - input, - expected: length, - actual: point.len(), - }) -} - fn normalize_stage4_registers_rw_point( program: &'static Stage4VerifierProgramPlan, driver: &'static str, @@ -2288,22 +2420,6 @@ fn normalize_stage4_registers_rw_point( .collect()) } -fn normalize_stage4_registers_rw_cycle_point( - point: &[F], - cycle_rounds: usize, - input: &'static str, -) -> Result, VerifyStage4Error> { - let cycle = point - .get(..cycle_rounds) - .filter(|cycle| cycle.len() == cycle_rounds) - .ok_or(VerifyStage4Error::InvalidInputLength { - input, - expected: cycle_rounds, - actual: point.len(), - })?; - Ok(cycle.iter().rev().copied().collect()) -} - "# } } @@ -2334,6 +2450,181 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } +fn resolve_stage4_output_claims( + output_values: &[Stage4SumcheckOutputValuePlan], + claim_asts: Vec, +) -> Result, EmitError> { + let output_values_by_symbol: BTreeMap<_, _> = output_values + .iter() + .map(|value| (value.symbol.as_str(), value)) + .collect(); + claim_asts + .into_iter() + .map(|claim| { + verify_count( + "sumcheck output claim local_values", + &claim.relation, + claim.local_values.len(), + claim.local_value_operands.len(), + )?; + if claim.local_values != claim.local_value_operands { + return Err(EmitError::new(format!( + "stage4 output claim for @{} local_values do not match operands", + claim.relation + ))); + } + let local_values = claim + .local_values + .iter() + .map(|symbol| { + output_values_by_symbol + .get(symbol.as_str()) + .copied() + .cloned() + .ok_or_else(|| { + EmitError::new(format!( + "stage4 output claim for @{} references missing output value @{symbol}", + claim.relation + )) + }) + }) + .collect::, EmitError>>()?; + Ok(Stage4SumcheckOutputClaimPlan { + relation: claim.relation, + local_values, + claim_value: claim.claim_value, + }) + }) + .collect() +} + +fn prune_prover_output_field_exprs( + field_exprs: &mut Vec, + claims: &[Stage4SumcheckClaimPlan], + output_claims: &[Stage4SumcheckOutputClaimAst], +) { + let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs + .iter() + .map(|expr| (expr.symbol.as_str(), expr)) + .collect(); + let sumcheck_claim_closure = field_expr_dependency_closure( + &field_exprs_by_symbol, + claims.iter().map(|claim| claim.claim_value.as_str()), + ); + let output_claim_closure = field_expr_dependency_closure( + &field_exprs_by_symbol, + output_claims.iter().map(|claim| claim.claim_value.as_str()), + ); + field_exprs.retain(|expr| { + !output_claim_closure.contains(&expr.symbol) + || sumcheck_claim_closure.contains(&expr.symbol) + }); +} + +fn field_expr_dependency_closure<'a>( + field_exprs_by_symbol: &BTreeMap<&str, &Stage4FieldExprPlan>, + roots: impl Iterator, +) -> BTreeSet { + let mut visited = BTreeSet::new(); + let mut stack = roots.map(str::to_owned).collect::>(); + while let Some(symbol) = stack.pop() { + if !visited.insert(symbol.clone()) { + continue; + } + let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { + continue; + }; + for operand in &expr.operands { + if field_exprs_by_symbol.contains_key(operand.as_str()) { + stack.push(operand.clone()); + } + } + } + visited +} + +fn verify_output_point_plan( + stage: &str, + local_value: &Stage4SumcheckOutputValuePlan, + point: &Stage4SumcheckOutputPointPlan, +) -> Result<(), EmitError> { + if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { + return Err(EmitError::new(format!( + "{stage} output value @{} has unsupported point segment `{}`", + local_value.symbol, point.segment + ))); + } + if !matches!( + point.length.as_str(), + "full" | "local_point" | "opening_point" + ) { + return Err(EmitError::new(format!( + "{stage} output value @{} has unsupported point length `{}`", + local_value.symbol, point.length + ))); + } + if !matches!(point.order.as_str(), "as_is" | "reverse") { + return Err(EmitError::new(format!( + "{stage} output value @{} has unsupported point order `{}`", + local_value.symbol, point.order + ))); + } + Ok(()) +} + +fn stage4_output_value_kind_expr(kind: &str) -> Result<&'static str, EmitError> { + match kind { + "eq_mle" => Ok("Stage4SumcheckOutputValueKind::EqMle"), + "eq_plus_one" => Ok("Stage4SumcheckOutputValueKind::EqPlusOne"), + "lt" => Ok("Stage4SumcheckOutputValueKind::Lt"), + _ => Err(EmitError::new(format!( + "unsupported stage4 output value kind `{kind}`" + ))), + } +} + +fn stage4_output_point_expr(point: &Stage4SumcheckOutputPointPlan) -> Result { + Ok(format!( + "Stage4SumcheckOutputPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", + rust_str(&point.source), + stage4_output_point_segment_expr(&point.segment)?, + stage4_output_point_length_expr(&point.length)?, + stage4_output_point_order_expr(&point.order)?, + )) +} + +fn stage4_output_point_segment_expr(segment: &str) -> Result<&'static str, EmitError> { + match segment { + "full" => Ok("Stage4SumcheckOutputPointSegment::Full"), + "prefix" => Ok("Stage4SumcheckOutputPointSegment::Prefix"), + "suffix" => Ok("Stage4SumcheckOutputPointSegment::Suffix"), + _ => Err(EmitError::new(format!( + "unsupported stage4 output point segment `{segment}`" + ))), + } +} + +fn stage4_output_point_length_expr(length: &str) -> Result<&'static str, EmitError> { + match length { + "full" => Ok("Stage4SumcheckOutputPointLength::Full"), + "local_point" => Ok("Stage4SumcheckOutputPointLength::LocalPoint"), + "opening_point" => Ok("Stage4SumcheckOutputPointLength::OpeningPoint"), + _ => Err(EmitError::new(format!( + "unsupported stage4 output point length `{length}`" + ))), + } +} + +fn stage4_output_point_order_expr(order: &str) -> Result<&'static str, EmitError> { + match order { + "as_is" => Ok("Stage4SumcheckOutputPointOrder::AsIs"), + "reverse" => Ok("Stage4SumcheckOutputPointOrder::Reverse"), + _ => Err(EmitError::new(format!( + "unsupported stage4 output point order `{order}`" + ))), + } +} + fn emit_str_array(name: &str, values: &[String]) -> String { if values.is_empty() { return format!("pub const {name}: &[&str] = &[];\n\n"); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 039b22c5bb..49d8073c3f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1243,6 +1243,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); + let output_claims_field = if self.role == Role::Verifier { + " output_claims: &[],\n" + } else { + "" + }; push_format( &mut source, format_args!( @@ -1261,6 +1266,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); \x20 drivers: STAGE5_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE5_SUMCHECK_EVALS,\n\ + {output_claims_field}\ \x20 point_slices: STAGE5_POINT_SLICES,\n\ \x20 point_concats: STAGE5_POINT_CONCATS,\n\ \x20 opening_claims: STAGE5_OPENING_CLAIMS,\n\ diff --git a/crates/bolt/src/protocols/jolt/phases/commitment.rs b/crates/bolt/src/protocols/jolt/phases/commitment.rs index 69f94cef38..a4cc41f563 100644 --- a/crates/bolt/src/protocols/jolt/phases/commitment.rs +++ b/crates/bolt/src/protocols/jolt/phases/commitment.rs @@ -925,7 +925,18 @@ pub fn lower_compute_to_cpu<'c>( "compute.sumcheck_output_value" => { let operands = lowered_operands(op, &value_map)?; let symbol = string_attr(op, "sym_name")?; - let attrs = copy_attrs(op, &["kind", "point_order"])?; + let attrs = copy_attrs( + op, + &[ + "kind", + "local_point_segment", + "local_point_length", + "local_point_order", + "opening_point_segment", + "opening_point_length", + "opening_point_order", + ], + )?; let operation = context.append_typed_op_with_owned_attrs( &cpu, "cpu.sumcheck_output_value", diff --git a/crates/bolt/src/protocols/jolt/phases/lowering.rs b/crates/bolt/src/protocols/jolt/phases/lowering.rs index 992672846d..fff89e7d9b 100644 --- a/crates/bolt/src/protocols/jolt/phases/lowering.rs +++ b/crates/bolt/src/protocols/jolt/phases/lowering.rs @@ -432,7 +432,18 @@ pub(super) fn lower_party_to_compute<'c>( "piop.sumcheck_output_value" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; - let attrs = copy_attrs(op, &["kind", "point_order"])?; + let attrs = copy_attrs( + op, + &[ + "kind", + "local_point_segment", + "local_point_length", + "local_point_order", + "opening_point_segment", + "opening_point_length", + "opening_point_order", + ], + )?; let operation = context.append_typed_op_with_owned_attrs( &compute, "compute.sumcheck_output_value", diff --git a/crates/bolt/src/protocols/jolt/phases/mod.rs b/crates/bolt/src/protocols/jolt/phases/mod.rs index e976bc9396..dfc56da7e3 100644 --- a/crates/bolt/src/protocols/jolt/phases/mod.rs +++ b/crates/bolt/src/protocols/jolt/phases/mod.rs @@ -1,5 +1,6 @@ mod field_formula; mod lowering; +mod sumcheck_output; pub mod commitment; pub mod stage1; diff --git a/crates/bolt/src/protocols/jolt/phases/stage1.rs b/crates/bolt/src/protocols/jolt/phases/stage1.rs index fd2f86c917..e7cca9f13a 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage1.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage1.rs @@ -851,7 +851,18 @@ pub fn resolve_compute_kernels<'c>( } "compute.sumcheck_output_value" => { let operands = lowered_operands(op, &value_map, 0)?; - let attrs = copy_attrs(op, &["kind", "point_order"])?; + let attrs = copy_attrs( + op, + &[ + "kind", + "local_point_segment", + "local_point_length", + "local_point_order", + "opening_point_segment", + "opening_point_length", + "opening_point_order", + ], + )?; let symbol = string_attr(op, "sym_name")?; let operation = context.append_typed_op_with_owned_attrs( &kernelized, diff --git a/crates/bolt/src/protocols/jolt/phases/stage3.rs b/crates/bolt/src/protocols/jolt/phases/stage3.rs index 7a02710549..3596e2f2c4 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage3.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage3.rs @@ -19,6 +19,10 @@ use super::lowering::{ copy_attrs, field_lowering_attrs as field_compute_attrs, string_attr, transcript_squeeze_compute_result_types, transcript_squeeze_protocol_result_type, }; +use super::sumcheck_output::{ + append_sumcheck_output_claim, append_sumcheck_output_value, OutputClaimSpec, OutputPointSpec, + OutputValueSpec, +}; const SPARTAN_SHIFT_DEGREE: usize = 2; const INSTRUCTION_INPUT_DEGREE: usize = 3; @@ -611,7 +615,18 @@ pub fn lower_stage3_to_compute<'c>( "piop.sumcheck_output_value" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; - let attrs = copy_attrs(op, &["kind", "point_order"])?; + let attrs = copy_attrs( + op, + &[ + "kind", + "local_point_segment", + "local_point_length", + "local_point_order", + "opening_point_segment", + "opening_point_length", + "opening_point_order", + ], + )?; let operation = context.append_typed_op_with_owned_attrs( &compute, "compute.sumcheck_output_value", @@ -1756,7 +1771,8 @@ fn append_stage3_output_claims<'c, 'a>( OutputValueSpec { symbol: "stage3.spartan_shift.output.eq.NextPC", kind: "eq_plus_one", - point_order: "reverse", + local_point: OutputPointSpec::full("reverse"), + opening_point: OutputPointSpec::full("as_is"), }, spec.instances.shift.0, spec.openings.next_pc.point, @@ -1767,7 +1783,8 @@ fn append_stage3_output_claims<'c, 'a>( OutputValueSpec { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", kind: "eq_plus_one", - point_order: "reverse", + local_point: OutputPointSpec::full("reverse"), + opening_point: OutputPointSpec::full("as_is"), }, spec.instances.shift.0, spec.openings.product_next_is_noop.point, @@ -1828,7 +1845,8 @@ fn append_stage3_output_claims<'c, 'a>( OutputValueSpec { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", kind: "eq_mle", - point_order: "reverse", + local_point: OutputPointSpec::full("reverse"), + opening_point: OutputPointSpec::full("as_is"), }, spec.instances.instruction.0, spec.openings.product_left_instruction_input.point, @@ -1896,7 +1914,8 @@ fn append_stage3_output_claims<'c, 'a>( OutputValueSpec { symbol: "stage3.registers.output.eq.RdWriteValue", kind: "eq_mle", - point_order: "reverse", + local_point: OutputPointSpec::full("reverse"), + opening_point: OutputPointSpec::full("as_is"), }, spec.instances.registers.0, spec.openings.rd_write_value.point, @@ -1940,57 +1959,6 @@ fn append_stage3_output_claims<'c, 'a>( ) } -fn append_sumcheck_output_value<'c, 'a>( - context: &'c MeliorContext, - module: &'a BoltModule<'c, Protocol>, - spec: OutputValueSpec<'_>, - local_point: Value<'c, 'a>, - opening_point: Value<'c, 'a>, -) -> Result, MlirError> { - let op = context.append_typed_op( - module, - "piop.sumcheck_output_value", - Some(spec.symbol), - &[ - ("kind", &format!("\"{}\"", spec.kind)), - ("point_order", &format!("\"{}\"", spec.point_order)), - ], - &[local_point, opening_point], - &["!field.scalar"], - )?; - first_result(op, "piop.sumcheck_output_value") -} - -fn append_sumcheck_output_claim<'c, 'a>( - context: &'c MeliorContext, - module: &'a BoltModule<'c, Protocol>, - spec: OutputClaimSpec<'_>, - claim_value: Value<'c, 'a>, - local_values: &[(&str, Value<'c, 'a>)], -) -> Result<(), MlirError> { - let mut operands = Vec::with_capacity(local_values.len() + 1); - operands.push(claim_value); - operands.extend(local_values.iter().map(|(_, value)| *value)); - let local_value_symbols = local_values - .iter() - .map(|(symbol, _)| *symbol) - .collect::>(); - let _op = context.append_typed_op( - module, - "piop.sumcheck_output_claim", - Some(spec.symbol), - &[ - ("stage", &format!("@{}", spec.stage)), - ("relation", &format!("@{}", spec.relation)), - ("count", &int_attr(local_values.len())), - ("local_values", &symbol_array_attr(&local_value_symbols)), - ], - &operands, - &[], - )?; - Ok(()) -} - fn append_sumcheck_claim<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, @@ -2472,15 +2440,3 @@ struct Stage3OutputClaimInputs<'c, 'a, 'b> { registers_gamma: Value<'c, 'a>, registers_gamma2: Value<'c, 'a>, } - -struct OutputValueSpec<'a> { - symbol: &'a str, - kind: &'a str, - point_order: &'a str, -} - -struct OutputClaimSpec<'a> { - symbol: &'a str, - stage: &'a str, - relation: &'a str, -} diff --git a/crates/bolt/src/protocols/jolt/phases/stage4.rs b/crates/bolt/src/protocols/jolt/phases/stage4.rs index adf6bc080a..71e70545b9 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage4.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage4.rs @@ -7,7 +7,12 @@ use crate::schema::{verify_protocol_schema, SchemaError}; use super::super::oracles; use super::super::params::JoltProtocolParams; +use super::field_formula::{FieldFormulaBuilder, FieldFormulaStep}; use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type}; +use super::sumcheck_output::{ + append_sumcheck_output_claim, append_sumcheck_output_value, OutputClaimSpec, OutputPointSpec, + OutputValueSpec, +}; const REGISTERS_RW_DEGREE: usize = 3; const RAM_VAL_CHECK_DEGREE: usize = 3; @@ -17,6 +22,72 @@ const STAGE4_REGISTER_INPUTS: [&str; 3] = ["RdWriteValue", "Rs1Value", "Rs2Value const STAGE4_REGISTER_OUTPUTS: [&str; 5] = ["RegistersVal", "Rs1Ra", "Rs2Ra", "RdWa", "RdInc"]; const STAGE4_RAM_VAL_OUTPUTS: [&str; 2] = ["RamRa", "RamInc"]; +const STAGE4_REGISTERS_OUTPUT_FORMULAS: [FieldFormulaStep; 9] = [ + FieldFormulaStep::add( + "stage4.registers_read_write.output.sum.RegistersValRdInc", + "stage4.registers_read_write.eval.RegistersVal", + "stage4.registers_read_write.eval.RdInc", + ), + FieldFormulaStep::mul( + "stage4.registers_read_write.output.term.RdWa", + "stage4.registers_read_write.eval.RdWa", + "stage4.registers_read_write.output.sum.RegistersValRdInc", + ), + FieldFormulaStep::mul( + "stage4.registers_read_write.output.term.Rs1Ra", + "stage4.registers_read_write.eval.Rs1Ra", + "stage4.registers_read_write.eval.RegistersVal", + ), + FieldFormulaStep::mul( + "stage4.registers_read_write.output.term.Rs2Ra", + "stage4.registers_read_write.eval.Rs2Ra", + "stage4.registers_read_write.eval.RegistersVal", + ), + FieldFormulaStep::mul( + "stage4.registers_read_write.output.weighted.Rs2Ra", + "stage4.registers_read_write.gamma", + "stage4.registers_read_write.output.term.Rs2Ra", + ), + FieldFormulaStep::add( + "stage4.registers_read_write.output.read_terms", + "stage4.registers_read_write.output.term.Rs1Ra", + "stage4.registers_read_write.output.weighted.Rs2Ra", + ), + FieldFormulaStep::mul( + "stage4.registers_read_write.output.weighted.read_terms", + "stage4.registers_read_write.gamma", + "stage4.registers_read_write.output.read_terms", + ), + FieldFormulaStep::add( + "stage4.registers_read_write.output.weighted_values", + "stage4.registers_read_write.output.term.RdWa", + "stage4.registers_read_write.output.weighted.read_terms", + ), + FieldFormulaStep::mul( + "stage4.registers_read_write.output.claim_expr", + "stage4.registers_read_write.output.eq.RdWriteValue", + "stage4.registers_read_write.output.weighted_values", + ), +]; + +const STAGE4_RAM_VAL_OUTPUT_FORMULAS: [FieldFormulaStep; 3] = [ + FieldFormulaStep::add( + "stage4.ram_val_check.output.lt_plus_gamma", + "stage4.ram_val_check.output.lt.RamValCycle", + "stage4.ram_val_check.gamma", + ), + FieldFormulaStep::mul( + "stage4.ram_val_check.output.term.RamIncRamRa", + "stage4.ram_val_check.eval.RamInc", + "stage4.ram_val_check.eval.RamRa", + ), + FieldFormulaStep::mul( + "stage4.ram_val_check.output.claim_expr", + "stage4.ram_val_check.output.term.RamIncRamRa", + "stage4.ram_val_check.output.lt_plus_gamma", + ), +]; + pub fn build_stage4_protocol<'c>( context: &'c MeliorContext, params: &JoltProtocolParams, @@ -656,7 +727,18 @@ fn append_stage4_batched_sumcheck<'c, 'a>( point, result_value, )?; - append_stage4_output_openings(context, module, params, inputs, registers, ram_val_check)?; + append_stage4_output_openings( + context, + module, + params, + Stage4OutputOpeningsInputs { + openings: inputs, + registers, + ram_val_check, + registers_gamma: spec.registers_gamma, + ram_val_check_gamma: spec.ram_val_check_gamma, + }, + )?; Ok(state) } @@ -664,12 +746,14 @@ fn append_stage4_output_openings<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, params: &JoltProtocolParams, - inputs: &Stage4OpeningInputs<'c, 'a>, - registers: (Value<'c, 'a>, Value<'c, 'a>), - ram_val_check: (Value<'c, 'a>, Value<'c, 'a>), + spec: Stage4OutputOpeningsInputs<'c, 'a, '_>, ) -> Result<(), MlirError> { + let inputs = spec.openings; + let registers = spec.registers; + let ram_val_check = spec.ram_val_check; let mut claims = Vec::new(); let mut claim_symbols = Vec::new(); + let mut register_evals = Vec::new(); for (index, &oracle) in ["RegistersVal", "Rs1Ra", "Rs2Ra", "RdWa"] .iter() @@ -685,6 +769,7 @@ fn append_stage4_output_openings<'c, 'a>( index, registers.1, )?; + register_evals.push(eval); claim_symbols.push(symbol.clone()); claims.push(append_opening_claim( context, @@ -799,6 +884,32 @@ fn append_stage4_output_openings<'c, 'a>( }, )?); + let [registers_val_eval, rs1_ra_eval, rs2_ra_eval, rd_wa_eval] = register_evals.as_slice() + else { + return Err(schema_error(format!( + "stage4 registers output eval count mismatch: expected 4, got {}", + register_evals.len() + ))); + }; + append_stage4_output_claims( + context, + module, + Stage4OutputClaimInputs { + openings: inputs, + registers, + ram_val_check, + registers_gamma: spec.registers_gamma, + ram_val_check_gamma: spec.ram_val_check_gamma, + registers_val_eval: *registers_val_eval, + rs1_ra_eval: *rs1_ra_eval, + rs2_ra_eval: *rs2_ra_eval, + rd_wa_eval: *rd_wa_eval, + rd_inc_eval, + ram_ra_eval, + ram_inc_eval, + }, + )?; + let claim_names = claim_symbols.iter().map(String::as_str).collect::>(); let _batch = context.append_typed_op( module, @@ -817,6 +928,90 @@ fn append_stage4_output_openings<'c, 'a>( Ok(()) } +fn append_stage4_output_claims<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + spec: Stage4OutputClaimInputs<'c, 'a, '_>, +) -> Result<(), MlirError> { + let registers_eq_trace = append_sumcheck_output_value( + context, + module, + OutputValueSpec { + symbol: "stage4.registers_read_write.output.eq.RdWriteValue", + kind: "eq_mle", + local_point: OutputPointSpec::prefix("opening_point", "reverse"), + opening_point: OutputPointSpec::full("as_is"), + }, + spec.registers.0, + spec.openings.rd_write_value.point, + )?; + let mut formula = FieldFormulaBuilder::new(context, module); + formula.bind_all(&[ + ("stage4.registers_read_write.gamma", spec.registers_gamma), + ( + "stage4.registers_read_write.eval.RegistersVal", + spec.registers_val_eval, + ), + ("stage4.registers_read_write.eval.Rs1Ra", spec.rs1_ra_eval), + ("stage4.registers_read_write.eval.Rs2Ra", spec.rs2_ra_eval), + ("stage4.registers_read_write.eval.RdWa", spec.rd_wa_eval), + ("stage4.registers_read_write.eval.RdInc", spec.rd_inc_eval), + ( + "stage4.registers_read_write.output.eq.RdWriteValue", + registers_eq_trace, + ), + ]); + formula.append_all(&STAGE4_REGISTERS_OUTPUT_FORMULAS)?; + let registers_claim = formula.value("stage4.registers_read_write.output.claim_expr")?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage4.registers_read_write.output.claim", + stage: "stage4", + relation: "jolt.stage4.registers_read_write", + }, + registers_claim, + &[( + "stage4.registers_read_write.output.eq.RdWriteValue", + registers_eq_trace, + )], + )?; + + let ram_lt = append_sumcheck_output_value( + context, + module, + OutputValueSpec { + symbol: "stage4.ram_val_check.output.lt.RamValCycle", + kind: "lt", + local_point: OutputPointSpec::full("reverse"), + opening_point: OutputPointSpec::suffix("local_point", "as_is"), + }, + spec.ram_val_check.0, + spec.openings.ram_val.point, + )?; + let mut formula = FieldFormulaBuilder::new(context, module); + formula.bind_all(&[ + ("stage4.ram_val_check.gamma", spec.ram_val_check_gamma), + ("stage4.ram_val_check.eval.RamRa", spec.ram_ra_eval), + ("stage4.ram_val_check.eval.RamInc", spec.ram_inc_eval), + ("stage4.ram_val_check.output.lt.RamValCycle", ram_lt), + ]); + formula.append_all(&STAGE4_RAM_VAL_OUTPUT_FORMULAS)?; + let ram_val_claim = formula.value("stage4.ram_val_check.output.claim_expr")?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage4.ram_val_check.output.claim", + stage: "stage4", + relation: "jolt.stage4.ram_val_check", + }, + ram_val_claim, + &[("stage4.ram_val_check.output.lt.RamValCycle", ram_lt)], + ) +} + fn append_opening_claim_equal<'c>( context: &'c MeliorContext, module: &BoltModule<'c, Protocol>, @@ -1183,6 +1378,29 @@ struct Stage4BatchedSumcheckInputs<'c, 'a, 'b> { ram_val_check_gamma: Value<'c, 'a>, } +struct Stage4OutputOpeningsInputs<'c, 'a, 'b> { + openings: &'b Stage4OpeningInputs<'c, 'a>, + registers: (Value<'c, 'a>, Value<'c, 'a>), + ram_val_check: (Value<'c, 'a>, Value<'c, 'a>), + registers_gamma: Value<'c, 'a>, + ram_val_check_gamma: Value<'c, 'a>, +} + +struct Stage4OutputClaimInputs<'c, 'a, 'b> { + openings: &'b Stage4OpeningInputs<'c, 'a>, + registers: (Value<'c, 'a>, Value<'c, 'a>), + ram_val_check: (Value<'c, 'a>, Value<'c, 'a>), + registers_gamma: Value<'c, 'a>, + ram_val_check_gamma: Value<'c, 'a>, + registers_val_eval: Value<'c, 'a>, + rs1_ra_eval: Value<'c, 'a>, + rs2_ra_eval: Value<'c, 'a>, + rd_wa_eval: Value<'c, 'a>, + rd_inc_eval: Value<'c, 'a>, + ram_ra_eval: Value<'c, 'a>, + ram_inc_eval: Value<'c, 'a>, +} + struct SumcheckClaimSpec<'a> { symbol: &'a str, stage: &'a str, diff --git a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs new file mode 100644 index 0000000000..1917a1aa62 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs @@ -0,0 +1,148 @@ +use melior::ir::Value; + +use crate::ir::{BoltModule, Protocol}; +use crate::mlir::{MeliorContext, MlirError}; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct OutputPointSpec<'a> { + segment: &'a str, + length: &'a str, + order: &'a str, +} + +impl<'a> OutputPointSpec<'a> { + pub(crate) const fn full(order: &'a str) -> Self { + Self { + segment: "full", + length: "full", + order, + } + } + + pub(crate) const fn prefix(length: &'a str, order: &'a str) -> Self { + Self { + segment: "prefix", + length, + order, + } + } + + pub(crate) const fn suffix(length: &'a str, order: &'a str) -> Self { + Self { + segment: "suffix", + length, + order, + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct OutputValueSpec<'a> { + pub(crate) symbol: &'a str, + pub(crate) kind: &'a str, + pub(crate) local_point: OutputPointSpec<'a>, + pub(crate) opening_point: OutputPointSpec<'a>, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct OutputClaimSpec<'a> { + pub(crate) symbol: &'a str, + pub(crate) stage: &'a str, + pub(crate) relation: &'a str, +} + +pub(crate) fn append_sumcheck_output_value<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + spec: OutputValueSpec<'_>, + local_point: Value<'c, 'a>, + opening_point: Value<'c, 'a>, +) -> Result, MlirError> { + let op = context.append_typed_op( + module, + "piop.sumcheck_output_value", + Some(spec.symbol), + &[ + ("kind", &format!("\"{}\"", spec.kind)), + ( + "local_point_segment", + &format!("\"{}\"", spec.local_point.segment), + ), + ( + "local_point_length", + &format!("\"{}\"", spec.local_point.length), + ), + ( + "local_point_order", + &format!("\"{}\"", spec.local_point.order), + ), + ( + "opening_point_segment", + &format!("\"{}\"", spec.opening_point.segment), + ), + ( + "opening_point_length", + &format!("\"{}\"", spec.opening_point.length), + ), + ( + "opening_point_order", + &format!("\"{}\"", spec.opening_point.order), + ), + ], + &[local_point, opening_point], + &["!field.scalar"], + )?; + first_result(op, "piop.sumcheck_output_value") +} + +pub(crate) fn append_sumcheck_output_claim<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + spec: OutputClaimSpec<'_>, + claim_value: Value<'c, 'a>, + local_values: &[(&str, Value<'c, 'a>)], +) -> Result<(), MlirError> { + let mut operands = Vec::with_capacity(local_values.len() + 1); + operands.push(claim_value); + operands.extend(local_values.iter().map(|(_, value)| *value)); + let local_value_symbols = local_values + .iter() + .map(|(symbol, _)| *symbol) + .collect::>(); + let _op = context.append_typed_op( + module, + "piop.sumcheck_output_claim", + Some(spec.symbol), + &[ + ("stage", &format!("@{}", spec.stage)), + ("relation", &format!("@{}", spec.relation)), + ("count", &int_attr(local_values.len())), + ("local_values", &symbol_array_attr(&local_value_symbols)), + ], + &operands, + &[], + )?; + Ok(()) +} + +fn first_result<'c, 'a>( + operation: melior::ir::operation::OperationRef<'c, 'a>, + operation_name: &str, +) -> Result, MlirError> { + operation.result(0).map(Into::into).map_err(|_| { + crate::schema::SchemaError::new(format!("{operation_name} requires result 0")).into() + }) +} + +fn int_attr(value: usize) -> String { + format!("{value} : i64") +} + +fn symbol_array_attr(values: &[&str]) -> String { + let values = values + .iter() + .map(|value| format!("@{value}")) + .collect::>() + .join(", "); + format!("[{values}]") +} diff --git a/crates/bolt/src/schema.rs b/crates/bolt/src/schema.rs index 7304983dab..fd1f17b4ec 100644 --- a/crates/bolt/src/schema.rs +++ b/crates/bolt/src/schema.rs @@ -14,6 +14,17 @@ use crate::ir::{ use crate::mlir::MlirError; use crate::pass::{verify_concrete_transcript, VerifyError}; +const SUMCHECK_OUTPUT_VALUE_ATTRS: &[&str] = &[ + "sym_name", + "kind", + "local_point_segment", + "local_point_length", + "local_point_order", + "opening_point_segment", + "opening_point_length", + "opening_point_order", +]; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct SchemaError { message: String, @@ -363,7 +374,7 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_shape(operation, 2, 2) } "piop.sumcheck_output_value" => { - require_attrs(operation, &["sym_name", "kind", "point_order"])?; + require_attrs(operation, SUMCHECK_OUTPUT_VALUE_ATTRS)?; require_shape(operation, 2, 1)?; require_sumcheck_output_value(operation) } @@ -720,7 +731,7 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_shape(operation, 2, 2) } "compute.sumcheck_output_value" => { - require_attrs(operation, &["sym_name", "kind", "point_order"])?; + require_attrs(operation, SUMCHECK_OUTPUT_VALUE_ATTRS)?; require_shape(operation, 2, 1)?; require_sumcheck_output_value(operation) } @@ -1060,7 +1071,7 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_shape(operation, 2, 2) } "cpu.sumcheck_output_value" => { - require_attrs(operation, &["sym_name", "kind", "point_order"])?; + require_attrs(operation, SUMCHECK_OUTPUT_VALUE_ATTRS)?; require_shape(operation, 2, 1)?; require_sumcheck_output_value(operation) } @@ -1199,16 +1210,48 @@ fn require_opening_claim_equality(operation: OperationRef<'_, '_>) -> Result<(), fn require_sumcheck_output_value(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> { let kind = string_attr(operation, "kind")?; - if !matches!(kind.as_str(), "eq_mle" | "eq_plus_one") { + if !matches!(kind.as_str(), "eq_mle" | "eq_plus_one" | "lt") { return Err(SchemaError::new(format!( "{} attr `kind` has unsupported output value kind `{kind}`", operation_name(operation) ))); } - let point_order = string_attr(operation, "point_order")?; - if !matches!(point_order.as_str(), "as_is" | "reverse") { + require_sumcheck_output_point_attrs(operation, "local_point")?; + require_sumcheck_output_point_attrs(operation, "opening_point")?; + Ok(()) +} + +fn require_sumcheck_output_point_attrs( + operation: OperationRef<'_, '_>, + prefix: &str, +) -> Result<(), SchemaError> { + let segment_attr = format!("{prefix}_segment"); + let segment = string_attr(operation, &segment_attr)?; + if !matches!(segment.as_str(), "full" | "prefix" | "suffix") { + return Err(SchemaError::new(format!( + "{} attr `{segment_attr}` has unsupported output point segment `{segment}`", + operation_name(operation) + ))); + } + let length_attr = format!("{prefix}_length"); + let length = string_attr(operation, &length_attr)?; + if !matches!(length.as_str(), "full" | "local_point" | "opening_point") { + return Err(SchemaError::new(format!( + "{} attr `{length_attr}` has unsupported output point length `{length}`", + operation_name(operation) + ))); + } + if segment == "full" && length != "full" { + return Err(SchemaError::new(format!( + "{} output point `{prefix}` uses segment `full` but length `{length}`; full segments must use length `full`", + operation_name(operation) + ))); + } + let order_attr = format!("{prefix}_order"); + let order = string_attr(operation, &order_attr)?; + if !matches!(order.as_str(), "as_is" | "reverse") { return Err(SchemaError::new(format!( - "{} attr `point_order` has unsupported output point order `{point_order}`", + "{} attr `{order_attr}` has unsupported output point order `{order}`", operation_name(operation) ))); } diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index a951b72c5b..a5ecaa79f1 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -309,10 +309,41 @@ fn generated_sumcheck_output_value_kind( match value { "eq_mle" => bolt_verifier_runtime::SumcheckOutputValueKind::EqMle, "eq_plus_one" => bolt_verifier_runtime::SumcheckOutputValueKind::EqPlusOne, + "lt" => bolt_verifier_runtime::SumcheckOutputValueKind::Lt, value => panic!("unsupported generated sumcheck output value kind `{value}`"), } } +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_sumcheck_output_point_segment( + value: &str, +) -> bolt_verifier_runtime::SumcheckOutputPointSegment { + match value { + "full" => bolt_verifier_runtime::SumcheckOutputPointSegment::Full, + "prefix" => bolt_verifier_runtime::SumcheckOutputPointSegment::Prefix, + "suffix" => bolt_verifier_runtime::SumcheckOutputPointSegment::Suffix, + value => panic!("unsupported generated sumcheck output point segment `{value}`"), + } +} + +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_sumcheck_output_point_length( + value: &str, +) -> bolt_verifier_runtime::SumcheckOutputPointLength { + match value { + "full" => bolt_verifier_runtime::SumcheckOutputPointLength::Full, + "local_point" => bolt_verifier_runtime::SumcheckOutputPointLength::LocalPoint, + "opening_point" => bolt_verifier_runtime::SumcheckOutputPointLength::OpeningPoint, + value => panic!("unsupported generated sumcheck output point length `{value}`"), + } +} + #[expect( clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" @@ -399,6 +430,7 @@ macro_rules! define_stage_adapter_impl { $(, kernels = $kernel:ident)? $(, point_zeros = $point_zero:ident)? $(, output_claims = $output_claim:ident, output_values = $output_value:ident)? + $(, empty_output_claims = $empty_output_claims:ident)? $(, opening_equalities = $opening_equality:ident)? ) => { pub fn $function(program: &$compiler) -> &'static $module::$program { @@ -559,15 +591,18 @@ macro_rules! define_stage_adapter_impl { .map(|value| $module::$output_value { symbol: super::leak_str(&value.symbol), kind: super::generated_sumcheck_output_value_kind(&value.kind), - point_order: super::generated_sumcheck_output_point_order( - &value.point_order, - ), - local_point_source: super::leak_str( - &value.local_point_source, - ), - opening_point_source: super::leak_str( - &value.opening_point_source, - ), + local_point: bolt_verifier_runtime::SumcheckOutputPointPlan { + source: super::leak_str(&value.local_point.source), + segment: super::generated_sumcheck_output_point_segment(&value.local_point.segment), + length: super::generated_sumcheck_output_point_length(&value.local_point.length), + order: super::generated_sumcheck_output_point_order(&value.local_point.order), + }, + opening_point: bolt_verifier_runtime::SumcheckOutputPointPlan { + source: super::leak_str(&value.opening_point.source), + segment: super::generated_sumcheck_output_point_segment(&value.opening_point.segment), + length: super::generated_sumcheck_output_point_length(&value.opening_point.length), + order: super::generated_sumcheck_output_point_order(&value.opening_point.order), + }, }) .collect(), ), @@ -577,6 +612,12 @@ macro_rules! define_stage_adapter_impl { ), )? $( + output_claims: { + let _ = stringify!($empty_output_claims); + &[] + }, + )? + $( point_zeros: super::leak_slice( program .point_zeros @@ -689,6 +730,8 @@ macro_rules! define_stage_adapter { $opening_equality:ident, $opening_batch:ident $(, point_zero = $point_zero:ident)? + $(, output_claims = $output_claim:ident, output_values = $output_value:ident)? + $(, empty_output_claims = $empty_output_claims:ident)? ) => { define_stage_adapter_impl!( $mode, @@ -714,7 +757,10 @@ macro_rules! define_stage_adapter { role = role, transcript_absorb_bytes = $absorb, kernels = $kernel - $(, point_zeros = $point_zero)?, + $(, point_zeros = $point_zero)? + $(, output_claims = $output_claim, output_values = $output_value)? + $(, empty_output_claims = $empty_output_claims)? + , opening_equalities = $opening_equality ); }; @@ -744,6 +790,7 @@ macro_rules! define_stage_adapter_no_absorb { $opening_batch:ident $(, kernels = $kernel:ident)? $(, output_claims = $output_claim:ident, output_values = $output_value:ident)? + $(, empty_output_claims = $empty_output_claims:ident)? $(, opening_equalities = $opening_equality:ident)? ) => { define_stage_adapter_impl!( @@ -769,6 +816,7 @@ macro_rules! define_stage_adapter_no_absorb { $opening_batch $(, kernels = $kernel)? $(, output_claims = $output_claim, output_values = $output_value)? + $(, empty_output_claims = $empty_output_claims)? $(, opening_equalities = $opening_equality)? ); }; diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs index a9340f0907..ae92aafe21 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs @@ -24,5 +24,7 @@ define_stage_adapter!( Stage4PointConcatPlan, Stage4OpeningClaimPlan, Stage4OpeningClaimEqualityPlan, - Stage4OpeningBatchPlan + Stage4OpeningBatchPlan, + output_claims = Stage4SumcheckOutputClaimPlan, + output_values = Stage4SumcheckOutputValuePlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs index 0033acb89a..ba4ce74004 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs @@ -24,5 +24,6 @@ define_stage_adapter!( Stage5PointConcatPlan, Stage5OpeningClaimPlan, Stage5OpeningClaimEqualityPlan, - Stage5OpeningBatchPlan + Stage5OpeningBatchPlan, + empty_output_claims = yes ); diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 6aef80af9e..d9fe65028a 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -33,7 +33,10 @@ pub use bolt_verifier_runtime::{ ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, + SumcheckOutputPointLength as Stage3SumcheckOutputPointLength, SumcheckOutputPointOrder as Stage3SumcheckOutputPointOrder, + SumcheckOutputPointPlan as Stage3SumcheckOutputPointPlan, + SumcheckOutputPointSegment as Stage3SumcheckOutputPointSegment, SumcheckOutputValueKind as Stage3SumcheckOutputValueKind, TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, @@ -208,16 +211,16 @@ pub const STAGE3_OPENING_BATCHES: &[Stage3OpeningBatchPlan] = &[ Stage3OpeningBatchPlan { symbol: "stage3.openings", stage: "stage3", proof_slot: "stage3.openings", policy: "jolt_stage3_output_order", count: 16, ordered_claims: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"], claim_operands: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"] }, ]; pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage3SumcheckOutputValuePlan] = &[ - Stage3SumcheckOutputValuePlan { symbol: "stage3.spartan_shift.output.eq.NextPC", kind: Stage3SumcheckOutputValueKind::EqPlusOne, point_order: Stage3SumcheckOutputPointOrder::Reverse, local_point_source: "stage3.spartan_shift.instance", opening_point_source: "stage3.input.stage1.NextPC" }, - Stage3SumcheckOutputValuePlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", kind: Stage3SumcheckOutputValueKind::EqPlusOne, point_order: Stage3SumcheckOutputPointOrder::Reverse, local_point_source: "stage3.spartan_shift.instance", opening_point_source: "stage3.input.stage2.product_virtual.NextIsNoop" }, + Stage3SumcheckOutputValuePlan { symbol: "stage3.spartan_shift.output.eq.NextPC", kind: Stage3SumcheckOutputValueKind::EqPlusOne, local_point: Stage3SumcheckOutputPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::Reverse }, opening_point: Stage3SumcheckOutputPointPlan { source: "stage3.input.stage1.NextPC", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::AsIs } }, + Stage3SumcheckOutputValuePlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", kind: Stage3SumcheckOutputValueKind::EqPlusOne, local_point: Stage3SumcheckOutputPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::Reverse }, opening_point: Stage3SumcheckOutputPointPlan { source: "stage3.input.stage2.product_virtual.NextIsNoop", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::AsIs } }, ]; pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage3SumcheckOutputValuePlan] = &[ - Stage3SumcheckOutputValuePlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", kind: Stage3SumcheckOutputValueKind::EqMle, point_order: Stage3SumcheckOutputPointOrder::Reverse, local_point_source: "stage3.instruction_input.instance", opening_point_source: "stage3.input.stage2.product_virtual.LeftInstructionInput" }, + Stage3SumcheckOutputValuePlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", kind: Stage3SumcheckOutputValueKind::EqMle, local_point: Stage3SumcheckOutputPointPlan { source: "stage3.instruction_input.instance", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::Reverse }, opening_point: Stage3SumcheckOutputPointPlan { source: "stage3.input.stage2.product_virtual.LeftInstructionInput", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::AsIs } }, ]; pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage3SumcheckOutputValuePlan] = &[ - Stage3SumcheckOutputValuePlan { symbol: "stage3.registers.output.eq.RdWriteValue", kind: Stage3SumcheckOutputValueKind::EqMle, point_order: Stage3SumcheckOutputPointOrder::Reverse, local_point_source: "stage3.registers_claim_reduction.instance", opening_point_source: "stage3.input.stage1.RdWriteValue" }, + Stage3SumcheckOutputValuePlan { symbol: "stage3.registers.output.eq.RdWriteValue", kind: Stage3SumcheckOutputValueKind::EqMle, local_point: Stage3SumcheckOutputPointPlan { source: "stage3.registers_claim_reduction.instance", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::Reverse }, opening_point: Stage3SumcheckOutputPointPlan { source: "stage3.input.stage1.RdWriteValue", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::AsIs } }, ]; pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[ diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index a18b126caa..28e5af6ef5 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -1,9 +1,7 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; -use super::jolt_relations::lt_polynomial_eval; +use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; use jolt_field::{Field, Fr}; -use jolt_poly::EqPolynomial; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -17,6 +15,8 @@ pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZe pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage4SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage4SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage4SumcheckOutputValuePlan = bolt_verifier_runtime::SumcheckOutputValuePlan; pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind; pub use bolt_verifier_runtime::{ @@ -32,6 +32,11 @@ pub use bolt_verifier_runtime::{ ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, SumcheckBatchPlan as Stage4SumcheckBatchPlan, SumcheckEvalPlan as Stage4SumcheckEvalPlan, + SumcheckOutputPointLength as Stage4SumcheckOutputPointLength, + SumcheckOutputPointOrder as Stage4SumcheckOutputPointOrder, + SumcheckOutputPointPlan as Stage4SumcheckOutputPointPlan, + SumcheckOutputPointSegment as Stage4SumcheckOutputPointSegment, + SumcheckOutputValueKind as Stage4SumcheckOutputValueKind, TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage4TranscriptSqueezeKind, TranscriptSqueezePlan as Stage4TranscriptSqueezePlan, @@ -97,6 +102,18 @@ pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[ Stage4FieldExprPlan { symbol: "stage4.ram_val_check.delta.RamValFinal", kind: Stage4FieldExprKind::Sub, operands: &["stage4.input.stage2.RamValFinal", "stage4.input.initial_ram.RamValInit"] }, Stage4FieldExprPlan { symbol: "stage4.ram_val_check.term.RamValFinal", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.gamma", "stage4.ram_val_check.delta.RamValFinal"] }, Stage4FieldExprPlan { symbol: "stage4.ram_val_check.claim_expr", kind: Stage4FieldExprKind::Add, operands: &["stage4.ram_val_check.delta.RamVal", "stage4.ram_val_check.term.RamValFinal"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.sum.RegistersValRdInc", kind: Stage4FieldExprKind::Add, operands: &["stage4.registers_read_write.eval.RegistersVal", "stage4.registers_read_write.eval.RdInc"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.term.RdWa", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.eval.RdWa", "stage4.registers_read_write.output.sum.RegistersValRdInc"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.term.Rs1Ra", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.eval.Rs1Ra", "stage4.registers_read_write.eval.RegistersVal"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.term.Rs2Ra", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.eval.Rs2Ra", "stage4.registers_read_write.eval.RegistersVal"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.weighted.Rs2Ra", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.gamma", "stage4.registers_read_write.output.term.Rs2Ra"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.read_terms", kind: Stage4FieldExprKind::Add, operands: &["stage4.registers_read_write.output.term.Rs1Ra", "stage4.registers_read_write.output.weighted.Rs2Ra"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.weighted.read_terms", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.gamma", "stage4.registers_read_write.output.read_terms"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.weighted_values", kind: Stage4FieldExprKind::Add, operands: &["stage4.registers_read_write.output.term.RdWa", "stage4.registers_read_write.output.weighted.read_terms"] }, + Stage4FieldExprPlan { symbol: "stage4.registers_read_write.output.claim_expr", kind: Stage4FieldExprKind::Mul, operands: &["stage4.registers_read_write.output.eq.RdWriteValue", "stage4.registers_read_write.output.weighted_values"] }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.lt_plus_gamma", kind: Stage4FieldExprKind::Add, operands: &["stage4.ram_val_check.output.lt.RamValCycle", "stage4.ram_val_check.gamma"] }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.term.RamIncRamRa", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.eval.RamInc", "stage4.ram_val_check.eval.RamRa"] }, + Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.claim_expr", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.output.term.RamIncRamRa", "stage4.ram_val_check.output.lt_plus_gamma"] }, ]; pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[ @@ -157,6 +174,19 @@ pub const STAGE4_OPENING_EQUALITIES: &[Stage4OpeningClaimEqualityPlan] = &[ pub const STAGE4_OPENING_BATCHES: &[Stage4OpeningBatchPlan] = &[ Stage4OpeningBatchPlan { symbol: "stage4.openings", stage: "stage4", proof_slot: "stage4.openings", policy: "jolt_stage4_output_order", count: 7, ordered_claims: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"], claim_operands: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"] }, ]; +pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage4SumcheckOutputValuePlan] = &[ + Stage4SumcheckOutputValuePlan { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", kind: Stage4SumcheckOutputValueKind::EqMle, local_point: Stage4SumcheckOutputPointPlan { source: "stage4.registers_read_write.instance", segment: Stage4SumcheckOutputPointSegment::Prefix, length: Stage4SumcheckOutputPointLength::OpeningPoint, order: Stage4SumcheckOutputPointOrder::Reverse }, opening_point: Stage4SumcheckOutputPointPlan { source: "stage4.input.stage3.registers.RdWriteValue", segment: Stage4SumcheckOutputPointSegment::Full, length: Stage4SumcheckOutputPointLength::Full, order: Stage4SumcheckOutputPointOrder::AsIs } }, +]; + +pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage4SumcheckOutputValuePlan] = &[ + Stage4SumcheckOutputValuePlan { symbol: "stage4.ram_val_check.output.lt.RamValCycle", kind: Stage4SumcheckOutputValueKind::Lt, local_point: Stage4SumcheckOutputPointPlan { source: "stage4.ram_val_check.instance", segment: Stage4SumcheckOutputPointSegment::Full, length: Stage4SumcheckOutputPointLength::Full, order: Stage4SumcheckOutputPointOrder::Reverse }, opening_point: Stage4SumcheckOutputPointPlan { source: "stage4.input.stage2.RamVal", segment: Stage4SumcheckOutputPointSegment::Suffix, length: Stage4SumcheckOutputPointLength::LocalPoint, order: Stage4SumcheckOutputPointOrder::AsIs } }, +]; + +pub const STAGE4_SUMCHECK_OUTPUT_CLAIMS: &[Stage4SumcheckOutputClaimPlan] = &[ + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, local_values: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage4.registers_read_write.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, local_values: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage4.ram_val_check.output.claim_expr" }, +]; + pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { role: "verifier", params: STAGE4_PARAMS, @@ -172,6 +202,7 @@ pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { drivers: STAGE4_SUMCHECK_DRIVERS, instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS, evals: STAGE4_SUMCHECK_EVALS, + output_claims: STAGE4_SUMCHECK_OUTPUT_CLAIMS, point_slices: STAGE4_POINT_SLICES, point_concats: STAGE4_POINT_CONCATS, opening_claims: STAGE4_OPENING_CLAIMS, @@ -424,86 +455,26 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let Some(relation) = claim.relation else { - return Err(VerifyStage4Error::InvalidProof { - driver: driver.symbol, - reason: "missing claim relation", - }); - }; - let value = match relation { - Stage4RelationKind::Stage4RegistersReadWrite => { - expected_registers_read_write(store, evals, local_point)? - } - Stage4RelationKind::Stage4RamValCheck => { - expected_ram_val_check(store, evals, local_point)? - } - relation => return Err(VerifyStage4Error::UnsupportedRelation { relation }), - }; + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage4Error::UnsupportedRelation { + relation: instance.relation, + })?; + let value = bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )?; expected += *coefficient * value; } Ok(expected) } -fn expected_registers_read_write( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage4NamedEval], - local_point: &[Fr], -) -> Result { - let trace_point = bolt_verifier_runtime::store_point(store, "stage4.input.stage3.registers.RdWriteValue")?; - let r_cycle = normalize_stage4_registers_rw_cycle_point( - local_point, - trace_point.len(), - "stage4.registers_read_write.instance", - )?; - let eq_eval = EqPolynomial::::mle(&r_cycle, trace_point); - let registers_val = eval_by_name( - evals, - "stage4.registers_read_write.eval.RegistersVal", - )?; - let rs1_ra = eval_by_name(evals, "stage4.registers_read_write.eval.Rs1Ra")?; - let rs2_ra = eval_by_name(evals, "stage4.registers_read_write.eval.Rs2Ra")?; - let rd_wa = eval_by_name(evals, "stage4.registers_read_write.eval.RdWa")?; - let rd_inc = eval_by_name(evals, "stage4.registers_read_write.eval.RdInc")?; - let gamma = bolt_verifier_runtime::store_scalar(store, "stage4.registers_read_write.gamma")?; - Ok(eq_eval - * (rd_wa * (registers_val + rd_inc) - + gamma * (rs1_ra * registers_val + gamma * rs2_ra * registers_val))) -} - -fn expected_ram_val_check( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage4NamedEval], - local_point: &[Fr], -) -> Result { - let ram_val_point = bolt_verifier_runtime::store_point(store, "stage4.input.stage2.RamVal")?; - let r_cycle_prime = reverse_slice(local_point); - let r_cycle = suffix_point( - ram_val_point, - r_cycle_prime.len(), - "stage4.input.stage2.RamVal", - )?; - let lt_eval = lt_polynomial_eval(&r_cycle_prime, r_cycle); - let gamma = bolt_verifier_runtime::store_scalar(store, "stage4.ram_val_check.gamma")?; - let ram_ra = eval_by_name(evals, "stage4.ram_val_check.eval.RamRa")?; - let ram_inc = eval_by_name(evals, "stage4.ram_val_check.eval.RamInc")?; - Ok(ram_inc * ram_ra * (lt_eval + gamma)) -} - -fn suffix_point<'a>( - point: &'a [Fr], - length: usize, - input: &'static str, -) -> Result<&'a [Fr], VerifyStage4Error> { - point - .get(point.len().saturating_sub(length)..) - .filter(|suffix| suffix.len() == length) - .ok_or(VerifyStage4Error::InvalidInputLength { - input, - expected: length, - actual: point.len(), - }) -} - fn normalize_stage4_registers_rw_point( program: &'static Stage4VerifierProgramPlan, driver: &'static str, @@ -535,19 +506,3 @@ fn normalize_stage4_registers_rw_point( .chain(cycle.iter().rev().copied()) .collect()) } - -fn normalize_stage4_registers_rw_cycle_point( - point: &[F], - cycle_rounds: usize, - input: &'static str, -) -> Result, VerifyStage4Error> { - let cycle = point - .get(..cycle_rounds) - .filter(|cycle| cycle.len() == cycle_rounds) - .ok_or(VerifyStage4Error::InvalidInputLength { - input, - expected: cycle_rounds, - actual: point.len(), - })?; - Ok(cycle.iter().rev().copied().collect()) -} diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index c7a473b8a1..608a8cdf69 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -284,6 +284,7 @@ pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { drivers: STAGE5_SUMCHECK_DRIVERS, instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS, evals: STAGE5_SUMCHECK_EVALS, + output_claims: &[], point_slices: STAGE5_POINT_SLICES, point_concats: STAGE5_POINT_CONCATS, opening_claims: STAGE5_OPENING_CLAIMS, From 960c59c2f796ab13ebbd9556c92be6abe54634d0 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 13:21:10 -0600 Subject: [PATCH 025/171] fix(bolt): clean verifier metadata Emit rustfmt-compatible verifier exports and remove the unused serde dependency from the generated verifier crate so CI fmt and machete agree with the generated artifact source of truth. --- Cargo.lock | 1 - crates/bolt/src/protocols/jolt/artifacts.rs | 5 ++--- crates/jolt-verifier/Cargo.toml | 1 - crates/jolt-verifier/src/lib.rs | 4 ++-- 4 files changed, 4 insertions(+), 7 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 312ab1d537..ef51a2e35e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3342,7 +3342,6 @@ dependencies = [ "jolt-poly", "jolt-sumcheck", "jolt-transcript", - "serde", "tracing", ] diff --git a/crates/bolt/src/protocols/jolt/artifacts.rs b/crates/bolt/src/protocols/jolt/artifacts.rs index cf2adeeab8..fdc31cc3b8 100644 --- a/crates/bolt/src/protocols/jolt/artifacts.rs +++ b/crates/bolt/src/protocols/jolt/artifacts.rs @@ -225,7 +225,6 @@ pub fn jolt_artifact_config() -> ProtocolArtifactConfig { "jolt-dory".to_owned(), "jolt-lookup-tables".to_owned(), "jolt-sumcheck".to_owned(), - "serde".to_owned(), ], instrumentation_prefix: Some("bolt".to_owned()), prover_forbidden_imports: PROVER_FORBIDDEN_IMPORTS @@ -333,8 +332,8 @@ pub use verifier::{ JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, JoltVerificationArtifacts, JoltVerifierCheckpoint, JoltVerifierInputs, - JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepPlan, - JoltVerifierStepKind, JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, + JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepKind, + JoltVerifierStepPlan, JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, JOLT_TARGET_FULL, JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6, JOLT_TARGET_THROUGH_STAGE7, JOLT_VERIFIER_STEPS, JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM, };" diff --git a/crates/jolt-verifier/Cargo.toml b/crates/jolt-verifier/Cargo.toml index df8f14efb2..c72cb32cb6 100644 --- a/crates/jolt-verifier/Cargo.toml +++ b/crates/jolt-verifier/Cargo.toml @@ -18,5 +18,4 @@ jolt-openings.workspace = true jolt-poly.workspace = true jolt-sumcheck.workspace = true jolt-transcript.workspace = true -serde.workspace = true tracing.workspace = true diff --git a/crates/jolt-verifier/src/lib.rs b/crates/jolt-verifier/src/lib.rs index 18f0a856a2..90f218a585 100644 --- a/crates/jolt-verifier/src/lib.rs +++ b/crates/jolt-verifier/src/lib.rs @@ -23,8 +23,8 @@ pub use verifier::{ JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput, JoltVerificationArtifacts, JoltVerifierCheckpoint, JoltVerifierInputs, - JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepPlan, - JoltVerifierStepKind, JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, + JoltVerifierProgramError, JoltVerifierProgramPlan, JoltVerifierPrograms, JoltVerifierStepKind, + JoltVerifierStepPlan, JoltVerifierTarget, JoltVerifierTargetPlan, JoltVerifyError, JOLT_TARGET_FULL, JOLT_TARGET_THROUGH_STAGE5, JOLT_TARGET_THROUGH_STAGE6, JOLT_TARGET_THROUGH_STAGE7, JOLT_VERIFIER_STEPS, JOLT_VERIFIER_TARGETS, VERIFIER_PROGRAM, }; From d6b3d98b0f9e90fd636b4f1bc55948372d87f65f Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 14:14:56 -0600 Subject: [PATCH 026/171] refactor(bolt): structure output polynomials Rename sumcheck output values into structured polynomial eval plans across IR, schema, emitters, runtime, generated artifacts, and equivalence adapters. Treat LT as the same verifier-side structured polynomial vocabulary as Eq and EqPlusOne, with explicit x/y point staging and polynomial_evals output claims. --- crates/bolt-verifier-runtime/src/lib.rs | 110 +++++----- crates/bolt/irdl/compute.mlir | 40 ++-- crates/bolt/irdl/cpu.mlir | 40 ++-- crates/bolt/irdl/piop.mlir | 38 ++-- .../src/protocols/jolt/emit/rust/stage3.rs | 190 +++++++++-------- .../src/protocols/jolt/emit/rust/stage4.rs | 196 ++++++++++-------- .../src/protocols/jolt/phases/commitment.rs | 20 +- .../src/protocols/jolt/phases/lowering.rs | 20 +- .../bolt/src/protocols/jolt/phases/stage1.rs | 20 +- .../bolt/src/protocols/jolt/phases/stage3.rs | 64 +++--- .../bolt/src/protocols/jolt/phases/stage4.rs | 24 +-- .../protocols/jolt/phases/sumcheck_output.rs | 70 +++---- crates/bolt/src/schema.rs | 66 +++--- crates/jolt-equivalence/src/plan_adapters.rs | 72 +++---- .../src/plan_adapters/generated_stage3.rs | 2 +- .../src/plan_adapters/generated_stage4.rs | 2 +- crates/jolt-verifier/src/stages/stage3.rs | 32 +-- crates/jolt-verifier/src/stages/stage4.rs | 24 +-- 18 files changed, 519 insertions(+), 511 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index fe63322e56..16bca14352 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -313,52 +313,52 @@ pub struct SumcheckInstanceResultPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum SumcheckOutputPointOrder { +pub enum StructuredPolynomialPointOrder { AsIs, Reverse, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum SumcheckOutputPointSegment { +pub enum StructuredPolynomialPointSegment { Full, Prefix, Suffix, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum SumcheckOutputPointLength { +pub enum StructuredPolynomialPointLength { Full, - LocalPoint, - OpeningPoint, + XPoint, + YPoint, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckOutputPointPlan { +pub struct StructuredPolynomialPointPlan { pub source: &'static str, - pub segment: SumcheckOutputPointSegment, - pub length: SumcheckOutputPointLength, - pub order: SumcheckOutputPointOrder, + pub segment: StructuredPolynomialPointSegment, + pub length: StructuredPolynomialPointLength, + pub order: StructuredPolynomialPointOrder, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum SumcheckOutputValueKind { - EqMle, +pub enum StructuredPolynomialKind { + Eq, EqPlusOne, Lt, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckOutputValuePlan { +pub struct StructuredPolynomialEvalPlan { pub symbol: &'static str, - pub kind: SumcheckOutputValueKind, - pub local_point: SumcheckOutputPointPlan, - pub opening_point: SumcheckOutputPointPlan, + pub polynomial: StructuredPolynomialKind, + pub x_point: StructuredPolynomialPointPlan, + pub y_point: StructuredPolynomialPointPlan, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct SumcheckOutputClaimPlan { pub relation: R, - pub local_values: &'static [SumcheckOutputValuePlan], + pub polynomial_evals: &'static [StructuredPolynomialEvalPlan], pub claim_value: &'static str, } @@ -1144,40 +1144,30 @@ pub fn evaluate_sumcheck_output_claim( for eval in evals { scratch.insert(eval.name, eval.value); } - for local_value in plan.local_values { - if local_value.local_point.source != instance_symbol { + for polynomial_eval in plan.polynomial_evals { + if polynomial_eval.x_point.source != instance_symbol { return Err(RuntimePlanError::InvalidProof { driver: instance_symbol, - reason: "sumcheck output value source mismatch", + reason: "structured polynomial x-point source mismatch", }); } - let opening_point = store.point_or(local_value.opening_point.source, |symbol| { + let y_raw_point = store.point_or(polynomial_eval.y_point.source, |symbol| { RuntimePlanError::MissingValue { symbol } })?; - let local_output_point = evaluate_sumcheck_output_point( - local_value.local_point, + let x_point = evaluate_structured_polynomial_point( + polynomial_eval.x_point, local_point, local_point, - opening_point, + y_raw_point, )?; - let opening_output_point = evaluate_sumcheck_output_point( - local_value.opening_point, - opening_point, + let y_point = evaluate_structured_polynomial_point( + polynomial_eval.y_point, + y_raw_point, local_point, - opening_point, + y_raw_point, )?; - let value = match local_value.kind { - SumcheckOutputValueKind::EqMle => { - EqPolynomial::::mle(&local_output_point, &opening_output_point) - } - SumcheckOutputValueKind::EqPlusOne => { - EqPlusOnePolynomial::::new(opening_output_point).evaluate(&local_output_point) - } - SumcheckOutputValueKind::Lt => { - lt_polynomial_eval(&local_output_point, &opening_output_point)? - } - }; - scratch.insert(local_value.symbol, value); + let value = evaluate_structured_polynomial(polynomial_eval.polynomial, &x_point, y_point)?; + scratch.insert(polynomial_eval.symbol, value); } evaluate_available_field_exprs_with_scratch(field_exprs, store, &mut scratch)?; scratch @@ -1187,14 +1177,14 @@ pub fn evaluate_sumcheck_output_claim( }) } -fn evaluate_sumcheck_output_point( - plan: SumcheckOutputPointPlan, +fn evaluate_structured_polynomial_point( + plan: StructuredPolynomialPointPlan, raw_point: &[Fr], - local_point: &[Fr], - opening_point: &[Fr], + x_point: &[Fr], + y_point: &[Fr], ) -> Result, RuntimePlanError> { - if matches!(plan.segment, SumcheckOutputPointSegment::Full) - && !matches!(plan.length, SumcheckOutputPointLength::Full) + if matches!(plan.segment, StructuredPolynomialPointSegment::Full) + && !matches!(plan.length, StructuredPolynomialPointLength::Full) { return Err(RuntimePlanError::InvalidProof { driver: plan.source, @@ -1202,13 +1192,13 @@ fn evaluate_sumcheck_output_point( }); } let length = match plan.length { - SumcheckOutputPointLength::Full => raw_point.len(), - SumcheckOutputPointLength::LocalPoint => local_point.len(), - SumcheckOutputPointLength::OpeningPoint => opening_point.len(), + StructuredPolynomialPointLength::Full => raw_point.len(), + StructuredPolynomialPointLength::XPoint => x_point.len(), + StructuredPolynomialPointLength::YPoint => y_point.len(), }; let segment = match plan.segment { - SumcheckOutputPointSegment::Full => raw_point, - SumcheckOutputPointSegment::Prefix => raw_point + StructuredPolynomialPointSegment::Full => raw_point, + StructuredPolynomialPointSegment::Prefix => raw_point .get(..length) .filter(|prefix| prefix.len() == length) .ok_or(RuntimePlanError::InvalidInputLength { @@ -1216,7 +1206,7 @@ fn evaluate_sumcheck_output_point( expected: length, actual: raw_point.len(), })?, - SumcheckOutputPointSegment::Suffix => raw_point + StructuredPolynomialPointSegment::Suffix => raw_point .get(raw_point.len().saturating_sub(length)..) .filter(|suffix| suffix.len() == length) .ok_or(RuntimePlanError::InvalidInputLength { @@ -1226,12 +1216,24 @@ fn evaluate_sumcheck_output_point( })?, }; Ok(match plan.order { - SumcheckOutputPointOrder::AsIs => segment.to_vec(), - SumcheckOutputPointOrder::Reverse => reverse_slice(segment), + StructuredPolynomialPointOrder::AsIs => segment.to_vec(), + StructuredPolynomialPointOrder::Reverse => reverse_slice(segment), + }) +} + +fn evaluate_structured_polynomial( + polynomial: StructuredPolynomialKind, + x: &[Fr], + y: Vec, +) -> Result { + Ok(match polynomial { + StructuredPolynomialKind::Eq => EqPolynomial::::mle(x, &y), + StructuredPolynomialKind::EqPlusOne => EqPlusOnePolynomial::::new(y).evaluate(x), + StructuredPolynomialKind::Lt => evaluate_lt_polynomial_mle(x, &y)?, }) } -fn lt_polynomial_eval(x: &[Fr], y: &[Fr]) -> Result { +fn evaluate_lt_polynomial_mle(x: &[Fr], y: &[Fr]) -> Result { if x.len() != y.len() { return Err(RuntimePlanError::InvalidInputLength { input: "sumcheck_output.lt", diff --git a/crates/bolt/irdl/compute.mlir b/crates/bolt/irdl/compute.mlir index 78d6433815..6989b62dc1 100644 --- a/crates/bolt/irdl/compute.mlir +++ b/crates/bolt/irdl/compute.mlir @@ -670,28 +670,28 @@ irdl.dialect @compute { irdl.operands(input_point: %input_point, input_result: %input_result) irdl.results(instance_point: %output_point, instance_result: %output_result) } - irdl.operation @sumcheck_output_value { + irdl.operation @structured_polynomial_eval { %point = irdl.parametric @compute::@point<> %value = irdl.parametric @compute::@field_value<> %sym = irdl.any - %kind = irdl.any - %local_point_segment = irdl.any - %local_point_length = irdl.any - %local_point_order = irdl.any - %opening_point_segment = irdl.any - %opening_point_length = irdl.any - %opening_point_order = irdl.any + %polynomial = irdl.any + %x_point_segment = irdl.any + %x_point_length = irdl.any + %x_point_order = irdl.any + %y_point_segment = irdl.any + %y_point_length = irdl.any + %y_point_order = irdl.any irdl.attributes { "sym_name" = %sym, - "kind" = %kind, - "local_point_segment" = %local_point_segment, - "local_point_length" = %local_point_length, - "local_point_order" = %local_point_order, - "opening_point_segment" = %opening_point_segment, - "opening_point_length" = %opening_point_length, - "opening_point_order" = %opening_point_order - } - irdl.operands(local_point: %point, opening_point: %point) + "polynomial" = %polynomial, + "x_point_segment" = %x_point_segment, + "x_point_length" = %x_point_length, + "x_point_order" = %x_point_order, + "y_point_segment" = %y_point_segment, + "y_point_length" = %y_point_length, + "y_point_order" = %y_point_order + } + irdl.operands(x_point: %point, y_point: %point) irdl.results(value: %value) } irdl.operation @sumcheck_output_claim { @@ -700,15 +700,15 @@ irdl.dialect @compute { %stage = irdl.any %relation = irdl.any %count = irdl.any - %local_values = irdl.any + %polynomial_evals = irdl.any irdl.attributes { "sym_name" = %sym, "stage" = %stage, "relation" = %relation, "count" = %count, - "local_values" = %local_values + "polynomial_evals" = %polynomial_evals } - irdl.operands(claim_value: %value, local_values: variadic %value) + irdl.operands(claim_value: %value, polynomial_evals: variadic %value) } irdl.operation @opening_claim { %point = irdl.parametric @compute::@point<> diff --git a/crates/bolt/irdl/cpu.mlir b/crates/bolt/irdl/cpu.mlir index 1352a50a58..da03f4941f 100644 --- a/crates/bolt/irdl/cpu.mlir +++ b/crates/bolt/irdl/cpu.mlir @@ -600,28 +600,28 @@ irdl.dialect @cpu { irdl.operands(input_point: %input_point, input_result: %input_result) irdl.results(instance_point: %output_point, instance_result: %output_result) } - irdl.operation @sumcheck_output_value { + irdl.operation @structured_polynomial_eval { %point = irdl.parametric @cpu::@point<> %value = irdl.parametric @cpu::@field_value<> %sym = irdl.any - %kind = irdl.any - %local_point_segment = irdl.any - %local_point_length = irdl.any - %local_point_order = irdl.any - %opening_point_segment = irdl.any - %opening_point_length = irdl.any - %opening_point_order = irdl.any + %polynomial = irdl.any + %x_point_segment = irdl.any + %x_point_length = irdl.any + %x_point_order = irdl.any + %y_point_segment = irdl.any + %y_point_length = irdl.any + %y_point_order = irdl.any irdl.attributes { "sym_name" = %sym, - "kind" = %kind, - "local_point_segment" = %local_point_segment, - "local_point_length" = %local_point_length, - "local_point_order" = %local_point_order, - "opening_point_segment" = %opening_point_segment, - "opening_point_length" = %opening_point_length, - "opening_point_order" = %opening_point_order - } - irdl.operands(local_point: %point, opening_point: %point) + "polynomial" = %polynomial, + "x_point_segment" = %x_point_segment, + "x_point_length" = %x_point_length, + "x_point_order" = %x_point_order, + "y_point_segment" = %y_point_segment, + "y_point_length" = %y_point_length, + "y_point_order" = %y_point_order + } + irdl.operands(x_point: %point, y_point: %point) irdl.results(value: %value) } irdl.operation @sumcheck_output_claim { @@ -630,15 +630,15 @@ irdl.dialect @cpu { %stage = irdl.any %relation = irdl.any %count = irdl.any - %local_values = irdl.any + %polynomial_evals = irdl.any irdl.attributes { "sym_name" = %sym, "stage" = %stage, "relation" = %relation, "count" = %count, - "local_values" = %local_values + "polynomial_evals" = %polynomial_evals } - irdl.operands(claim_value: %value, local_values: variadic %value) + irdl.operands(claim_value: %value, polynomial_evals: variadic %value) } irdl.operation @opening_claim { %point = irdl.parametric @cpu::@point<> diff --git a/crates/bolt/irdl/piop.mlir b/crates/bolt/irdl/piop.mlir index d45339ec42..93f3ff1069 100644 --- a/crates/bolt/irdl/piop.mlir +++ b/crates/bolt/irdl/piop.mlir @@ -218,28 +218,28 @@ irdl.dialect @piop { irdl.operands(input_point: %input_point, input_result: %input_result) irdl.results(instance_point: %output_point, instance_result: %output_result) } - irdl.operation @sumcheck_output_value { + irdl.operation @structured_polynomial_eval { %point = irdl.parametric @poly::@point<> %value = irdl.parametric @field::@scalar<> %sym = irdl.any - %kind = irdl.any - %local_point_segment = irdl.any - %local_point_length = irdl.any - %local_point_order = irdl.any - %opening_point_segment = irdl.any - %opening_point_length = irdl.any - %opening_point_order = irdl.any + %polynomial = irdl.any + %x_point_segment = irdl.any + %x_point_length = irdl.any + %x_point_order = irdl.any + %y_point_segment = irdl.any + %y_point_length = irdl.any + %y_point_order = irdl.any irdl.attributes { "sym_name" = %sym, - "kind" = %kind, - "local_point_segment" = %local_point_segment, - "local_point_length" = %local_point_length, - "local_point_order" = %local_point_order, - "opening_point_segment" = %opening_point_segment, - "opening_point_length" = %opening_point_length, - "opening_point_order" = %opening_point_order + "polynomial" = %polynomial, + "x_point_segment" = %x_point_segment, + "x_point_length" = %x_point_length, + "x_point_order" = %x_point_order, + "y_point_segment" = %y_point_segment, + "y_point_length" = %y_point_length, + "y_point_order" = %y_point_order } - irdl.operands(local_point: %point, opening_point: %point) + irdl.operands(x_point: %point, y_point: %point) irdl.results(value: %value) } irdl.operation @sumcheck_output_claim { @@ -248,15 +248,15 @@ irdl.dialect @piop { %stage = irdl.any %relation = irdl.any %count = irdl.any - %local_values = irdl.any + %polynomial_evals = irdl.any irdl.attributes { "sym_name" = %sym, "stage" = %stage, "relation" = %relation, "count" = %count, - "local_values" = %local_values + "polynomial_evals" = %polynomial_evals } - irdl.operands(claim_value: %value, local_values: variadic %value) + irdl.operands(claim_value: %value, polynomial_evals: variadic %value) } irdl.operation @opening_claim { %point = irdl.parametric @poly::@point<> diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 69a9a7c5df..ac693df897 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -23,7 +23,7 @@ pub struct Stage3CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, - pub output_values: Vec, + pub output_values: Vec, pub output_claims: Vec, pub point_slices: Vec, pub point_concats: Vec, @@ -148,7 +148,7 @@ pub struct Stage3SumcheckInstanceResultPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3SumcheckOutputPointPlan { +pub struct Stage3StructuredPolynomialPointPlan { pub source: String, pub segment: String, pub length: String, @@ -156,17 +156,17 @@ pub struct Stage3SumcheckOutputPointPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3SumcheckOutputValuePlan { +pub struct Stage3StructuredPolynomialEvalPlan { pub symbol: String, - pub kind: String, - pub local_point: Stage3SumcheckOutputPointPlan, - pub opening_point: Stage3SumcheckOutputPointPlan, + pub polynomial: String, + pub x_point: Stage3StructuredPolynomialPointPlan, + pub y_point: Stage3StructuredPolynomialPointPlan, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage3SumcheckOutputClaimPlan { pub relation: String, - pub local_values: Vec, + pub polynomial_evals: Vec, pub claim_value: String, } @@ -174,8 +174,8 @@ pub struct Stage3SumcheckOutputClaimPlan { struct Stage3SumcheckOutputClaimAst { relation: String, claim_value: String, - local_values: Vec, - local_value_operands: Vec, + polynomial_evals: Vec, + polynomial_eval_operands: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -480,21 +480,21 @@ impl Stage3CpuProgram { oracle: symbol_attr(op, "oracle")?, }); } - "cpu.sumcheck_output_value" => { - output_values.push(Stage3SumcheckOutputValuePlan { + "cpu.structured_polynomial_eval" => { + output_values.push(Stage3StructuredPolynomialEvalPlan { symbol: string_attr(op, "sym_name")?, - kind: string_attr(op, "kind")?, - local_point: Stage3SumcheckOutputPointPlan { + polynomial: string_attr(op, "polynomial")?, + x_point: Stage3StructuredPolynomialPointPlan { source: operand_symbol(op, 0)?, - segment: string_attr(op, "local_point_segment")?, - length: string_attr(op, "local_point_length")?, - order: string_attr(op, "local_point_order")?, + segment: string_attr(op, "x_point_segment")?, + length: string_attr(op, "x_point_length")?, + order: string_attr(op, "x_point_order")?, }, - opening_point: Stage3SumcheckOutputPointPlan { + y_point: Stage3StructuredPolynomialPointPlan { source: operand_symbol(op, 1)?, - segment: string_attr(op, "opening_point_segment")?, - length: string_attr(op, "opening_point_length")?, - order: string_attr(op, "opening_point_order")?, + segment: string_attr(op, "y_point_segment")?, + length: string_attr(op, "y_point_length")?, + order: string_attr(op, "y_point_order")?, }, }); } @@ -502,8 +502,8 @@ impl Stage3CpuProgram { output_claim_asts.push(Stage3SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, claim_value: operand_symbol(op, 0)?, - local_values: symbol_array_attr(op, "local_values")?, - local_value_operands: operand_symbols(op, 1)?, + polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, + polynomial_eval_operands: operand_symbols(op, 1)?, }); } "cpu.point_slice" => { @@ -880,27 +880,38 @@ impl Stage3CpuProgram { ); let field_values = self.field_value_symbols(); let point_values = self.point_value_symbols(); - for local_value in &self.output_values { - if !point_values.contains(&local_value.local_point.source) { + for polynomial_eval in &self.output_values { + if !point_values.contains(&polynomial_eval.x_point.source) { return Err(EmitError::new(format!( - "stage3 output value @{} references missing local point @{}", - local_value.symbol, local_value.local_point.source + "stage3 structured polynomial eval @{} references missing x-point @{}", + polynomial_eval.symbol, polynomial_eval.x_point.source ))); } - if !point_values.contains(&local_value.opening_point.source) { + if !point_values.contains(&polynomial_eval.y_point.source) { return Err(EmitError::new(format!( - "stage3 output value @{} references missing opening point @{}", - local_value.symbol, local_value.opening_point.source + "stage3 structured polynomial eval @{} references missing y-point @{}", + polynomial_eval.symbol, polynomial_eval.y_point.source ))); } - if !matches!(local_value.kind.as_str(), "eq_mle" | "eq_plus_one" | "lt") { + if !matches!( + polynomial_eval.polynomial.as_str(), + "eq" | "eq_plus_one" | "lt" + ) { return Err(EmitError::new(format!( - "stage3 output value @{} has unsupported kind `{}`", - local_value.symbol, local_value.kind + "stage3 structured polynomial eval @{} has unsupported polynomial `{}`", + polynomial_eval.symbol, polynomial_eval.polynomial ))); } - verify_output_point_plan("stage3", local_value, &local_value.local_point)?; - verify_output_point_plan("stage3", local_value, &local_value.opening_point)?; + verify_structured_polynomial_point_plan( + "stage3", + polynomial_eval, + &polynomial_eval.x_point, + )?; + verify_structured_polynomial_point_plan( + "stage3", + polynomial_eval, + &polynomial_eval.y_point, + )?; } for claim in &self.output_claims { if !relations.contains(&claim.relation) { @@ -1114,7 +1125,7 @@ pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage3SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; -pub type Stage3SumcheckOutputValuePlan = bolt_verifier_runtime::SumcheckOutputValuePlan; +pub type Stage3StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind; pub use bolt_verifier_runtime::{ @@ -1129,11 +1140,11 @@ pub use bolt_verifier_runtime::{ ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, - SumcheckOutputPointLength as Stage3SumcheckOutputPointLength, - SumcheckOutputPointOrder as Stage3SumcheckOutputPointOrder, - SumcheckOutputPointPlan as Stage3SumcheckOutputPointPlan, - SumcheckOutputPointSegment as Stage3SumcheckOutputPointSegment, - SumcheckOutputValueKind as Stage3SumcheckOutputValueKind, + StructuredPolynomialPointLength as Stage3StructuredPolynomialPointLength, + StructuredPolynomialPointOrder as Stage3StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan as Stage3StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment as Stage3StructuredPolynomialPointSegment, + StructuredPolynomialKind as Stage3StructuredPolynomialKind, TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, }; @@ -1689,15 +1700,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); for (index, claim) in self.output_claims.iter().enumerate() { let values_name = format!("STAGE3_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES"); let values = claim - .local_values + .polynomial_evals .iter() .map(|value| { Ok(format!( - " Stage3SumcheckOutputValuePlan {{ symbol: {}, kind: {}, local_point: {}, opening_point: {} }},", + " Stage3StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", rust_str(&value.symbol), - stage3_output_value_kind_expr(&value.kind)?, - stage3_output_point_expr(&value.local_point)?, - stage3_output_point_expr(&value.opening_point)?, + stage3_structured_polynomial_kind_expr(&value.polynomial)?, + stage3_structured_polynomial_point_expr(&value.x_point)?, + stage3_structured_polynomial_point_expr(&value.y_point)?, )) }) .collect::, EmitError>>()? @@ -1705,11 +1716,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); push_format( &mut source, format_args!( - "pub const {values_name}: &[Stage3SumcheckOutputValuePlan] = &[\n{values}\n];\n\n" + "pub const {values_name}: &[Stage3StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" ), ); claims.push(format!( - " Stage3SumcheckOutputClaimPlan {{ relation: {}, local_values: {values_name}, claim_value: {} }},", + " Stage3SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, claim_value: {} }},", super::plan_tokens::role_relation_kind_expr("Stage3", &self.role, &claim.relation)?, rust_str(&claim.claim_value) )); @@ -2191,7 +2202,7 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } fn resolve_stage3_output_claims( - output_values: &[Stage3SumcheckOutputValuePlan], + output_values: &[Stage3StructuredPolynomialEvalPlan], claim_asts: Vec, ) -> Result, EmitError> { let output_values_by_symbol: BTreeMap<_, _> = output_values @@ -2201,14 +2212,14 @@ fn resolve_stage3_output_claims( claim_asts .into_iter() .map(|claim| { - if claim.local_values != claim.local_value_operands { + if claim.polynomial_evals != claim.polynomial_eval_operands { return Err(EmitError::new(format!( - "stage3 output claim for @{} operand order does not match local_values", + "stage3 output claim for @{} operand order does not match polynomial_evals", claim.relation ))); } - let local_values = claim - .local_values + let polynomial_evals = claim + .polynomial_evals .iter() .map(|symbol| { output_values_by_symbol @@ -2224,7 +2235,7 @@ fn resolve_stage3_output_claims( .collect::, EmitError>>()?; Ok(Stage3SumcheckOutputClaimPlan { relation: claim.relation, - local_values, + polynomial_evals, claim_value: claim.claim_value, }) }) @@ -2276,82 +2287,83 @@ fn field_expr_dependency_closure<'a>( visited } -fn verify_output_point_plan( +fn verify_structured_polynomial_point_plan( stage: &str, - local_value: &Stage3SumcheckOutputValuePlan, - point: &Stage3SumcheckOutputPointPlan, + polynomial_eval: &Stage3StructuredPolynomialEvalPlan, + point: &Stage3StructuredPolynomialPointPlan, ) -> Result<(), EmitError> { if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { return Err(EmitError::new(format!( - "{stage} output value @{} has unsupported point segment `{}`", - local_value.symbol, point.segment + "{stage} structured polynomial eval @{} has unsupported point segment `{}`", + polynomial_eval.symbol, point.segment ))); } - if !matches!( - point.length.as_str(), - "full" | "local_point" | "opening_point" - ) { + if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { return Err(EmitError::new(format!( - "{stage} output value @{} has unsupported point length `{}`", - local_value.symbol, point.length + "{stage} structured polynomial eval @{} has unsupported point length `{}`", + polynomial_eval.symbol, point.length ))); } if !matches!(point.order.as_str(), "as_is" | "reverse") { return Err(EmitError::new(format!( - "{stage} output value @{} has unsupported point order `{}`", - local_value.symbol, point.order + "{stage} structured polynomial eval @{} has unsupported point order `{}`", + polynomial_eval.symbol, point.order ))); } Ok(()) } -fn stage3_output_value_kind_expr(kind: &str) -> Result<&'static str, EmitError> { - match kind { - "eq_mle" => Ok("Stage3SumcheckOutputValueKind::EqMle"), - "eq_plus_one" => Ok("Stage3SumcheckOutputValueKind::EqPlusOne"), - "lt" => Ok("Stage3SumcheckOutputValueKind::Lt"), +fn stage3_structured_polynomial_kind_expr(polynomial: &str) -> Result<&'static str, EmitError> { + match polynomial { + "eq" => Ok("Stage3StructuredPolynomialKind::Eq"), + "eq_plus_one" => Ok("Stage3StructuredPolynomialKind::EqPlusOne"), + "lt" => Ok("Stage3StructuredPolynomialKind::Lt"), _ => Err(EmitError::new(format!( - "unsupported stage3 output value kind `{kind}`" + "unsupported stage3 structured polynomial `{polynomial}`" ))), } } -fn stage3_output_point_expr(point: &Stage3SumcheckOutputPointPlan) -> Result { +fn stage3_structured_polynomial_point_expr( + point: &Stage3StructuredPolynomialPointPlan, +) -> Result { Ok(format!( - "Stage3SumcheckOutputPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", + "Stage3StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", rust_str(&point.source), - stage3_output_point_segment_expr(&point.segment)?, - stage3_output_point_length_expr(&point.length)?, - stage3_output_point_order_expr(&point.order)?, + stage3_structured_polynomial_point_segment_expr(&point.segment)?, + stage3_structured_polynomial_point_length_expr(&point.length)?, + stage3_structured_polynomial_point_order_expr(&point.order)?, )) } -fn stage3_output_point_segment_expr(segment: &str) -> Result<&'static str, EmitError> { +fn stage3_structured_polynomial_point_segment_expr( + segment: &str, +) -> Result<&'static str, EmitError> { match segment { - "full" => Ok("Stage3SumcheckOutputPointSegment::Full"), - "prefix" => Ok("Stage3SumcheckOutputPointSegment::Prefix"), - "suffix" => Ok("Stage3SumcheckOutputPointSegment::Suffix"), + "full" => Ok("Stage3StructuredPolynomialPointSegment::Full"), + "prefix" => Ok("Stage3StructuredPolynomialPointSegment::Prefix"), + "suffix" => Ok("Stage3StructuredPolynomialPointSegment::Suffix"), _ => Err(EmitError::new(format!( "unsupported stage3 output point segment `{segment}`" ))), } } -fn stage3_output_point_length_expr(length: &str) -> Result<&'static str, EmitError> { +fn stage3_structured_polynomial_point_length_expr(length: &str) -> Result<&'static str, EmitError> { match length { - "full" => Ok("Stage3SumcheckOutputPointLength::Full"), - "local_point" => Ok("Stage3SumcheckOutputPointLength::LocalPoint"), - "opening_point" => Ok("Stage3SumcheckOutputPointLength::OpeningPoint"), + "full" => Ok("Stage3StructuredPolynomialPointLength::Full"), + "x_point" => Ok("Stage3StructuredPolynomialPointLength::XPoint"), + "y_point" => Ok("Stage3StructuredPolynomialPointLength::YPoint"), _ => Err(EmitError::new(format!( - "unsupported stage3 output point length `{length}`" + "unsupported stage3 structured polynomial point length `{length}`" ))), } } -fn stage3_output_point_order_expr(order: &str) -> Result<&'static str, EmitError> { +fn stage3_structured_polynomial_point_order_expr(order: &str) -> Result<&'static str, EmitError> { match order { - "as_is" => Ok("Stage3SumcheckOutputPointOrder::AsIs"), - "reverse" => Ok("Stage3SumcheckOutputPointOrder::Reverse"), + "as_is" => Ok("Stage3StructuredPolynomialPointOrder::AsIs"), + "reverse" => Ok("Stage3StructuredPolynomialPointOrder::Reverse"), _ => Err(EmitError::new(format!( "unsupported stage3 output point order `{order}`" ))), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index ef72386101..9c063c7455 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -29,7 +29,7 @@ pub struct Stage4CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, - pub output_values: Vec, + pub output_values: Vec, pub output_claims: Vec, pub point_slices: Vec, pub point_concats: Vec, @@ -170,7 +170,7 @@ pub struct Stage4SumcheckEvalPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4SumcheckOutputPointPlan { +pub struct Stage4StructuredPolynomialPointPlan { pub source: String, pub segment: String, pub length: String, @@ -178,25 +178,25 @@ pub struct Stage4SumcheckOutputPointPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4SumcheckOutputValuePlan { +pub struct Stage4StructuredPolynomialEvalPlan { pub symbol: String, - pub kind: String, - pub local_point: Stage4SumcheckOutputPointPlan, - pub opening_point: Stage4SumcheckOutputPointPlan, + pub polynomial: String, + pub x_point: Stage4StructuredPolynomialPointPlan, + pub y_point: Stage4StructuredPolynomialPointPlan, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage4SumcheckOutputClaimPlan { pub relation: String, - pub local_values: Vec, + pub polynomial_evals: Vec, pub claim_value: String, } #[derive(Clone, Debug, PartialEq, Eq)] struct Stage4SumcheckOutputClaimAst { relation: String, - local_values: Vec, - local_value_operands: Vec, + polynomial_evals: Vec, + polynomial_eval_operands: Vec, claim_value: String, } @@ -491,21 +491,21 @@ impl Stage4CpuProgram { oracle: symbol_attr(op, "oracle")?, }); } - "cpu.sumcheck_output_value" => { - output_values.push(Stage4SumcheckOutputValuePlan { + "cpu.structured_polynomial_eval" => { + output_values.push(Stage4StructuredPolynomialEvalPlan { symbol: string_attr(op, "sym_name")?, - kind: string_attr(op, "kind")?, - local_point: Stage4SumcheckOutputPointPlan { + polynomial: string_attr(op, "polynomial")?, + x_point: Stage4StructuredPolynomialPointPlan { source: operand_symbol(op, 0)?, - segment: string_attr(op, "local_point_segment")?, - length: string_attr(op, "local_point_length")?, - order: string_attr(op, "local_point_order")?, + segment: string_attr(op, "x_point_segment")?, + length: string_attr(op, "x_point_length")?, + order: string_attr(op, "x_point_order")?, }, - opening_point: Stage4SumcheckOutputPointPlan { + y_point: Stage4StructuredPolynomialPointPlan { source: operand_symbol(op, 1)?, - segment: string_attr(op, "opening_point_segment")?, - length: string_attr(op, "opening_point_length")?, - order: string_attr(op, "opening_point_order")?, + segment: string_attr(op, "y_point_segment")?, + length: string_attr(op, "y_point_length")?, + order: string_attr(op, "y_point_order")?, }, }); } @@ -513,8 +513,8 @@ impl Stage4CpuProgram { output_claim_asts.push(Stage4SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, claim_value: operand_symbol(op, 0)?, - local_values: symbol_array_attr(op, "local_values")?, - local_value_operands: operand_symbols(op, 1)?, + polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, + polynomial_eval_operands: operand_symbols(op, 1)?, }); } "cpu.point_slice" => { @@ -896,27 +896,38 @@ impl Stage4CpuProgram { point_values.extend(symbols( self.point_concats.iter().map(|concat| &concat.symbol), )); - for local_value in &self.output_values { - if !point_values.contains(&local_value.local_point.source) { + for polynomial_eval in &self.output_values { + if !point_values.contains(&polynomial_eval.x_point.source) { return Err(EmitError::new(format!( - "stage4 output value @{} references missing local point @{}", - local_value.symbol, local_value.local_point.source + "stage4 structured polynomial eval @{} references missing x-point @{}", + polynomial_eval.symbol, polynomial_eval.x_point.source ))); } - if !point_values.contains(&local_value.opening_point.source) { + if !point_values.contains(&polynomial_eval.y_point.source) { return Err(EmitError::new(format!( - "stage4 output value @{} references missing opening point @{}", - local_value.symbol, local_value.opening_point.source + "stage4 structured polynomial eval @{} references missing y-point @{}", + polynomial_eval.symbol, polynomial_eval.y_point.source ))); } - if !matches!(local_value.kind.as_str(), "eq_mle" | "eq_plus_one" | "lt") { + if !matches!( + polynomial_eval.polynomial.as_str(), + "eq" | "eq_plus_one" | "lt" + ) { return Err(EmitError::new(format!( - "stage4 output value @{} has unsupported kind `{}`", - local_value.symbol, local_value.kind + "stage4 structured polynomial eval @{} has unsupported polynomial `{}`", + polynomial_eval.symbol, polynomial_eval.polynomial ))); } - verify_output_point_plan("stage4", local_value, &local_value.local_point)?; - verify_output_point_plan("stage4", local_value, &local_value.opening_point)?; + verify_structured_polynomial_point_plan( + "stage4", + polynomial_eval, + &polynomial_eval.x_point, + )?; + verify_structured_polynomial_point_plan( + "stage4", + polynomial_eval, + &polynomial_eval.y_point, + )?; } for claim in &self.output_claims { if !relations.contains(&claim.relation) { @@ -1322,7 +1333,7 @@ pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage4SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; -pub type Stage4SumcheckOutputValuePlan = bolt_verifier_runtime::SumcheckOutputValuePlan; +pub type Stage4StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind; pub use bolt_verifier_runtime::{ @@ -1338,11 +1349,11 @@ pub use bolt_verifier_runtime::{ ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, SumcheckBatchPlan as Stage4SumcheckBatchPlan, SumcheckEvalPlan as Stage4SumcheckEvalPlan, - SumcheckOutputPointLength as Stage4SumcheckOutputPointLength, - SumcheckOutputPointOrder as Stage4SumcheckOutputPointOrder, - SumcheckOutputPointPlan as Stage4SumcheckOutputPointPlan, - SumcheckOutputPointSegment as Stage4SumcheckOutputPointSegment, - SumcheckOutputValueKind as Stage4SumcheckOutputValueKind, + StructuredPolynomialPointLength as Stage4StructuredPolynomialPointLength, + StructuredPolynomialPointOrder as Stage4StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan as Stage4StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment as Stage4StructuredPolynomialPointSegment, + StructuredPolynomialKind as Stage4StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage4TranscriptSqueezeKind, TranscriptSqueezePlan as Stage4TranscriptSqueezePlan, @@ -1888,15 +1899,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); for (index, claim) in self.output_claims.iter().enumerate() { let values_name = format!("STAGE4_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES"); let values = claim - .local_values + .polynomial_evals .iter() .map(|value| { Ok(format!( - " Stage4SumcheckOutputValuePlan {{ symbol: {}, kind: {}, local_point: {}, opening_point: {} }},", + " Stage4StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", rust_str(&value.symbol), - stage4_output_value_kind_expr(&value.kind)?, - stage4_output_point_expr(&value.local_point)?, - stage4_output_point_expr(&value.opening_point)?, + stage4_structured_polynomial_kind_expr(&value.polynomial)?, + stage4_structured_polynomial_point_expr(&value.x_point)?, + stage4_structured_polynomial_point_expr(&value.y_point)?, )) }) .collect::, EmitError>>()? @@ -1904,11 +1915,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); push_format( &mut source, format_args!( - "pub const {values_name}: &[Stage4SumcheckOutputValuePlan] = &[\n{values}\n];\n\n" + "pub const {values_name}: &[Stage4StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" ), ); claims.push(format!( - " Stage4SumcheckOutputClaimPlan {{ relation: {}, local_values: {values_name}, claim_value: {} }},", + " Stage4SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, claim_value: {} }},", super::plan_tokens::role_relation_kind_expr("Stage4", &self.role, &claim.relation)?, rust_str(&claim.claim_value) )); @@ -2451,7 +2462,7 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } fn resolve_stage4_output_claims( - output_values: &[Stage4SumcheckOutputValuePlan], + output_values: &[Stage4StructuredPolynomialEvalPlan], claim_asts: Vec, ) -> Result, EmitError> { let output_values_by_symbol: BTreeMap<_, _> = output_values @@ -2462,19 +2473,19 @@ fn resolve_stage4_output_claims( .into_iter() .map(|claim| { verify_count( - "sumcheck output claim local_values", + "sumcheck output claim polynomial_evals", &claim.relation, - claim.local_values.len(), - claim.local_value_operands.len(), + claim.polynomial_evals.len(), + claim.polynomial_eval_operands.len(), )?; - if claim.local_values != claim.local_value_operands { + if claim.polynomial_evals != claim.polynomial_eval_operands { return Err(EmitError::new(format!( - "stage4 output claim for @{} local_values do not match operands", + "stage4 output claim for @{} polynomial_evals do not match operands", claim.relation ))); } - let local_values = claim - .local_values + let polynomial_evals = claim + .polynomial_evals .iter() .map(|symbol| { output_values_by_symbol @@ -2491,7 +2502,7 @@ fn resolve_stage4_output_claims( .collect::, EmitError>>()?; Ok(Stage4SumcheckOutputClaimPlan { relation: claim.relation, - local_values, + polynomial_evals, claim_value: claim.claim_value, }) }) @@ -2543,82 +2554,83 @@ fn field_expr_dependency_closure<'a>( visited } -fn verify_output_point_plan( +fn verify_structured_polynomial_point_plan( stage: &str, - local_value: &Stage4SumcheckOutputValuePlan, - point: &Stage4SumcheckOutputPointPlan, + polynomial_eval: &Stage4StructuredPolynomialEvalPlan, + point: &Stage4StructuredPolynomialPointPlan, ) -> Result<(), EmitError> { if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { return Err(EmitError::new(format!( - "{stage} output value @{} has unsupported point segment `{}`", - local_value.symbol, point.segment + "{stage} structured polynomial eval @{} has unsupported point segment `{}`", + polynomial_eval.symbol, point.segment ))); } - if !matches!( - point.length.as_str(), - "full" | "local_point" | "opening_point" - ) { + if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { return Err(EmitError::new(format!( - "{stage} output value @{} has unsupported point length `{}`", - local_value.symbol, point.length + "{stage} structured polynomial eval @{} has unsupported point length `{}`", + polynomial_eval.symbol, point.length ))); } if !matches!(point.order.as_str(), "as_is" | "reverse") { return Err(EmitError::new(format!( - "{stage} output value @{} has unsupported point order `{}`", - local_value.symbol, point.order + "{stage} structured polynomial eval @{} has unsupported point order `{}`", + polynomial_eval.symbol, point.order ))); } Ok(()) } -fn stage4_output_value_kind_expr(kind: &str) -> Result<&'static str, EmitError> { - match kind { - "eq_mle" => Ok("Stage4SumcheckOutputValueKind::EqMle"), - "eq_plus_one" => Ok("Stage4SumcheckOutputValueKind::EqPlusOne"), - "lt" => Ok("Stage4SumcheckOutputValueKind::Lt"), +fn stage4_structured_polynomial_kind_expr(polynomial: &str) -> Result<&'static str, EmitError> { + match polynomial { + "eq" => Ok("Stage4StructuredPolynomialKind::Eq"), + "eq_plus_one" => Ok("Stage4StructuredPolynomialKind::EqPlusOne"), + "lt" => Ok("Stage4StructuredPolynomialKind::Lt"), _ => Err(EmitError::new(format!( - "unsupported stage4 output value kind `{kind}`" + "unsupported stage4 structured polynomial `{polynomial}`" ))), } } -fn stage4_output_point_expr(point: &Stage4SumcheckOutputPointPlan) -> Result { +fn stage4_structured_polynomial_point_expr( + point: &Stage4StructuredPolynomialPointPlan, +) -> Result { Ok(format!( - "Stage4SumcheckOutputPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", + "Stage4StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", rust_str(&point.source), - stage4_output_point_segment_expr(&point.segment)?, - stage4_output_point_length_expr(&point.length)?, - stage4_output_point_order_expr(&point.order)?, + stage4_structured_polynomial_point_segment_expr(&point.segment)?, + stage4_structured_polynomial_point_length_expr(&point.length)?, + stage4_structured_polynomial_point_order_expr(&point.order)?, )) } -fn stage4_output_point_segment_expr(segment: &str) -> Result<&'static str, EmitError> { +fn stage4_structured_polynomial_point_segment_expr( + segment: &str, +) -> Result<&'static str, EmitError> { match segment { - "full" => Ok("Stage4SumcheckOutputPointSegment::Full"), - "prefix" => Ok("Stage4SumcheckOutputPointSegment::Prefix"), - "suffix" => Ok("Stage4SumcheckOutputPointSegment::Suffix"), + "full" => Ok("Stage4StructuredPolynomialPointSegment::Full"), + "prefix" => Ok("Stage4StructuredPolynomialPointSegment::Prefix"), + "suffix" => Ok("Stage4StructuredPolynomialPointSegment::Suffix"), _ => Err(EmitError::new(format!( "unsupported stage4 output point segment `{segment}`" ))), } } -fn stage4_output_point_length_expr(length: &str) -> Result<&'static str, EmitError> { +fn stage4_structured_polynomial_point_length_expr(length: &str) -> Result<&'static str, EmitError> { match length { - "full" => Ok("Stage4SumcheckOutputPointLength::Full"), - "local_point" => Ok("Stage4SumcheckOutputPointLength::LocalPoint"), - "opening_point" => Ok("Stage4SumcheckOutputPointLength::OpeningPoint"), + "full" => Ok("Stage4StructuredPolynomialPointLength::Full"), + "x_point" => Ok("Stage4StructuredPolynomialPointLength::XPoint"), + "y_point" => Ok("Stage4StructuredPolynomialPointLength::YPoint"), _ => Err(EmitError::new(format!( - "unsupported stage4 output point length `{length}`" + "unsupported stage4 structured polynomial point length `{length}`" ))), } } -fn stage4_output_point_order_expr(order: &str) -> Result<&'static str, EmitError> { +fn stage4_structured_polynomial_point_order_expr(order: &str) -> Result<&'static str, EmitError> { match order { - "as_is" => Ok("Stage4SumcheckOutputPointOrder::AsIs"), - "reverse" => Ok("Stage4SumcheckOutputPointOrder::Reverse"), + "as_is" => Ok("Stage4StructuredPolynomialPointOrder::AsIs"), + "reverse" => Ok("Stage4StructuredPolynomialPointOrder::Reverse"), _ => Err(EmitError::new(format!( "unsupported stage4 output point order `{order}`" ))), diff --git a/crates/bolt/src/protocols/jolt/phases/commitment.rs b/crates/bolt/src/protocols/jolt/phases/commitment.rs index a4cc41f563..cafb4f6380 100644 --- a/crates/bolt/src/protocols/jolt/phases/commitment.rs +++ b/crates/bolt/src/protocols/jolt/phases/commitment.rs @@ -922,24 +922,24 @@ pub fn lower_compute_to_cpu<'c>( insert_result_mapping(&mut value_map, op, operation, 0, 0)?; insert_result_mapping(&mut value_map, op, operation, 1, 1)?; } - "compute.sumcheck_output_value" => { + "compute.structured_polynomial_eval" => { let operands = lowered_operands(op, &value_map)?; let symbol = string_attr(op, "sym_name")?; let attrs = copy_attrs( op, &[ - "kind", - "local_point_segment", - "local_point_length", - "local_point_order", - "opening_point_segment", - "opening_point_length", - "opening_point_order", + "polynomial", + "x_point_segment", + "x_point_length", + "x_point_order", + "y_point_segment", + "y_point_length", + "y_point_order", ], )?; let operation = context.append_typed_op_with_owned_attrs( &cpu, - "cpu.sumcheck_output_value", + "cpu.structured_polynomial_eval", Some(&symbol), &attrs, &operands, @@ -950,7 +950,7 @@ pub fn lower_compute_to_cpu<'c>( "compute.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map)?; let symbol = string_attr(op, "sym_name")?; - let attrs = copy_attrs(op, &["stage", "relation", "count", "local_values"])?; + let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?; let _operation = context.append_typed_op_with_owned_attrs( &cpu, "cpu.sumcheck_output_claim", diff --git a/crates/bolt/src/protocols/jolt/phases/lowering.rs b/crates/bolt/src/protocols/jolt/phases/lowering.rs index fff89e7d9b..1c8d982b00 100644 --- a/crates/bolt/src/protocols/jolt/phases/lowering.rs +++ b/crates/bolt/src/protocols/jolt/phases/lowering.rs @@ -429,24 +429,24 @@ pub(super) fn lower_party_to_compute<'c>( insert_result_mapping(&mut value_map, op, operation, 0, 0)?; insert_result_mapping(&mut value_map, op, operation, 1, 1)?; } - "piop.sumcheck_output_value" => { + "piop.structured_polynomial_eval" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; let attrs = copy_attrs( op, &[ - "kind", - "local_point_segment", - "local_point_length", - "local_point_order", - "opening_point_segment", - "opening_point_length", - "opening_point_order", + "polynomial", + "x_point_segment", + "x_point_length", + "x_point_order", + "y_point_segment", + "y_point_length", + "y_point_order", ], )?; let operation = context.append_typed_op_with_owned_attrs( &compute, - "compute.sumcheck_output_value", + "compute.structured_polynomial_eval", Some(&symbol), &attrs, &operands, @@ -457,7 +457,7 @@ pub(super) fn lower_party_to_compute<'c>( "piop.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; - let attrs = copy_attrs(op, &["stage", "relation", "count", "local_values"])?; + let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?; let _operation = context.append_typed_op_with_owned_attrs( &compute, "compute.sumcheck_output_claim", diff --git a/crates/bolt/src/protocols/jolt/phases/stage1.rs b/crates/bolt/src/protocols/jolt/phases/stage1.rs index e7cca9f13a..644fbc5bf2 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage1.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage1.rs @@ -849,24 +849,24 @@ pub fn resolve_compute_kernels<'c>( insert_result_mapping(&mut value_map, op, operation, 0, 0)?; insert_result_mapping(&mut value_map, op, operation, 1, 1)?; } - "compute.sumcheck_output_value" => { + "compute.structured_polynomial_eval" => { let operands = lowered_operands(op, &value_map, 0)?; let attrs = copy_attrs( op, &[ - "kind", - "local_point_segment", - "local_point_length", - "local_point_order", - "opening_point_segment", - "opening_point_length", - "opening_point_order", + "polynomial", + "x_point_segment", + "x_point_length", + "x_point_order", + "y_point_segment", + "y_point_length", + "y_point_order", ], )?; let symbol = string_attr(op, "sym_name")?; let operation = context.append_typed_op_with_owned_attrs( &kernelized, - "compute.sumcheck_output_value", + "compute.structured_polynomial_eval", Some(&symbol), &attrs, &operands, @@ -876,7 +876,7 @@ pub fn resolve_compute_kernels<'c>( } "compute.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map, 0)?; - let attrs = copy_attrs(op, &["stage", "relation", "count", "local_values"])?; + let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?; let symbol = string_attr(op, "sym_name")?; let _operation = context.append_typed_op_with_owned_attrs( &kernelized, diff --git a/crates/bolt/src/protocols/jolt/phases/stage3.rs b/crates/bolt/src/protocols/jolt/phases/stage3.rs index 3596e2f2c4..c8eda21692 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage3.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage3.rs @@ -20,8 +20,8 @@ use super::lowering::{ transcript_squeeze_compute_result_types, transcript_squeeze_protocol_result_type, }; use super::sumcheck_output::{ - append_sumcheck_output_claim, append_sumcheck_output_value, OutputClaimSpec, OutputPointSpec, - OutputValueSpec, + append_structured_polynomial_eval, append_sumcheck_output_claim, OutputClaimSpec, + StructuredPolynomialPointSpec, StructuredPolynomialSpec, }; const SPARTAN_SHIFT_DEGREE: usize = 2; @@ -612,24 +612,24 @@ pub fn lower_stage3_to_compute<'c>( insert_result_mapping(&mut value_map, op, operation, 0, 0)?; insert_result_mapping(&mut value_map, op, operation, 1, 1)?; } - "piop.sumcheck_output_value" => { + "piop.structured_polynomial_eval" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; let attrs = copy_attrs( op, &[ - "kind", - "local_point_segment", - "local_point_length", - "local_point_order", - "opening_point_segment", - "opening_point_length", - "opening_point_order", + "polynomial", + "x_point_segment", + "x_point_length", + "x_point_order", + "y_point_segment", + "y_point_length", + "y_point_order", ], )?; let operation = context.append_typed_op_with_owned_attrs( &compute, - "compute.sumcheck_output_value", + "compute.structured_polynomial_eval", Some(&symbol), &attrs, &operands, @@ -640,7 +640,7 @@ pub fn lower_stage3_to_compute<'c>( "piop.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; - let attrs = copy_attrs(op, &["stage", "relation", "count", "local_values"])?; + let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?; let _operation = context.append_typed_op_with_owned_attrs( &compute, "compute.sumcheck_output_claim", @@ -1765,26 +1765,26 @@ fn append_stage3_output_claims<'c, 'a>( module: &'a BoltModule<'c, Protocol>, spec: Stage3OutputClaimInputs<'c, 'a, '_>, ) -> Result<(), MlirError> { - let shift_eq_next_pc = append_sumcheck_output_value( + let shift_eq_next_pc = append_structured_polynomial_eval( context, module, - OutputValueSpec { + StructuredPolynomialSpec { symbol: "stage3.spartan_shift.output.eq.NextPC", - kind: "eq_plus_one", - local_point: OutputPointSpec::full("reverse"), - opening_point: OutputPointSpec::full("as_is"), + polynomial: "eq_plus_one", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::full("as_is"), }, spec.instances.shift.0, spec.openings.next_pc.point, )?; - let shift_eq_next_is_noop = append_sumcheck_output_value( + let shift_eq_next_is_noop = append_structured_polynomial_eval( context, module, - OutputValueSpec { + StructuredPolynomialSpec { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", - kind: "eq_plus_one", - local_point: OutputPointSpec::full("reverse"), - opening_point: OutputPointSpec::full("as_is"), + polynomial: "eq_plus_one", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::full("as_is"), }, spec.instances.shift.0, spec.openings.product_next_is_noop.point, @@ -1839,14 +1839,14 @@ fn append_stage3_output_claims<'c, 'a>( ], )?; - let instruction_eq_left = append_sumcheck_output_value( + let instruction_eq_left = append_structured_polynomial_eval( context, module, - OutputValueSpec { + StructuredPolynomialSpec { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", - kind: "eq_mle", - local_point: OutputPointSpec::full("reverse"), - opening_point: OutputPointSpec::full("as_is"), + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::full("as_is"), }, spec.instances.instruction.0, spec.openings.product_left_instruction_input.point, @@ -1908,14 +1908,14 @@ fn append_stage3_output_claims<'c, 'a>( )], )?; - let registers_eq_rd_write = append_sumcheck_output_value( + let registers_eq_rd_write = append_structured_polynomial_eval( context, module, - OutputValueSpec { + StructuredPolynomialSpec { symbol: "stage3.registers.output.eq.RdWriteValue", - kind: "eq_mle", - local_point: OutputPointSpec::full("reverse"), - opening_point: OutputPointSpec::full("as_is"), + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::full("as_is"), }, spec.instances.registers.0, spec.openings.rd_write_value.point, diff --git a/crates/bolt/src/protocols/jolt/phases/stage4.rs b/crates/bolt/src/protocols/jolt/phases/stage4.rs index 71e70545b9..6fdc021be1 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage4.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage4.rs @@ -10,8 +10,8 @@ use super::super::params::JoltProtocolParams; use super::field_formula::{FieldFormulaBuilder, FieldFormulaStep}; use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type}; use super::sumcheck_output::{ - append_sumcheck_output_claim, append_sumcheck_output_value, OutputClaimSpec, OutputPointSpec, - OutputValueSpec, + append_structured_polynomial_eval, append_sumcheck_output_claim, OutputClaimSpec, + StructuredPolynomialPointSpec, StructuredPolynomialSpec, }; const REGISTERS_RW_DEGREE: usize = 3; @@ -933,14 +933,14 @@ fn append_stage4_output_claims<'c, 'a>( module: &'a BoltModule<'c, Protocol>, spec: Stage4OutputClaimInputs<'c, 'a, '_>, ) -> Result<(), MlirError> { - let registers_eq_trace = append_sumcheck_output_value( + let registers_eq_trace = append_structured_polynomial_eval( context, module, - OutputValueSpec { + StructuredPolynomialSpec { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", - kind: "eq_mle", - local_point: OutputPointSpec::prefix("opening_point", "reverse"), - opening_point: OutputPointSpec::full("as_is"), + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::prefix("y_point", "reverse"), + y_point: StructuredPolynomialPointSpec::full("as_is"), }, spec.registers.0, spec.openings.rd_write_value.point, @@ -978,14 +978,14 @@ fn append_stage4_output_claims<'c, 'a>( )], )?; - let ram_lt = append_sumcheck_output_value( + let ram_lt = append_structured_polynomial_eval( context, module, - OutputValueSpec { + StructuredPolynomialSpec { symbol: "stage4.ram_val_check.output.lt.RamValCycle", - kind: "lt", - local_point: OutputPointSpec::full("reverse"), - opening_point: OutputPointSpec::suffix("local_point", "as_is"), + polynomial: "lt", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"), }, spec.ram_val_check.0, spec.openings.ram_val.point, diff --git a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs index 1917a1aa62..fde809d924 100644 --- a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs +++ b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs @@ -4,13 +4,13 @@ use crate::ir::{BoltModule, Protocol}; use crate::mlir::{MeliorContext, MlirError}; #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) struct OutputPointSpec<'a> { +pub(crate) struct StructuredPolynomialPointSpec<'a> { segment: &'a str, length: &'a str, order: &'a str, } -impl<'a> OutputPointSpec<'a> { +impl<'a> StructuredPolynomialPointSpec<'a> { pub(crate) const fn full(order: &'a str) -> Self { Self { segment: "full", @@ -37,11 +37,11 @@ impl<'a> OutputPointSpec<'a> { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) struct OutputValueSpec<'a> { +pub(crate) struct StructuredPolynomialSpec<'a> { pub(crate) symbol: &'a str, - pub(crate) kind: &'a str, - pub(crate) local_point: OutputPointSpec<'a>, - pub(crate) opening_point: OutputPointSpec<'a>, + pub(crate) polynomial: &'a str, + pub(crate) x_point: StructuredPolynomialPointSpec<'a>, + pub(crate) y_point: StructuredPolynomialPointSpec<'a>, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -51,48 +51,30 @@ pub(crate) struct OutputClaimSpec<'a> { pub(crate) relation: &'a str, } -pub(crate) fn append_sumcheck_output_value<'c, 'a>( +pub(crate) fn append_structured_polynomial_eval<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, - spec: OutputValueSpec<'_>, - local_point: Value<'c, 'a>, - opening_point: Value<'c, 'a>, + spec: StructuredPolynomialSpec<'_>, + x_point: Value<'c, 'a>, + y_point: Value<'c, 'a>, ) -> Result, MlirError> { let op = context.append_typed_op( module, - "piop.sumcheck_output_value", + "piop.structured_polynomial_eval", Some(spec.symbol), &[ - ("kind", &format!("\"{}\"", spec.kind)), - ( - "local_point_segment", - &format!("\"{}\"", spec.local_point.segment), - ), - ( - "local_point_length", - &format!("\"{}\"", spec.local_point.length), - ), - ( - "local_point_order", - &format!("\"{}\"", spec.local_point.order), - ), - ( - "opening_point_segment", - &format!("\"{}\"", spec.opening_point.segment), - ), - ( - "opening_point_length", - &format!("\"{}\"", spec.opening_point.length), - ), - ( - "opening_point_order", - &format!("\"{}\"", spec.opening_point.order), - ), + ("polynomial", &format!("\"{}\"", spec.polynomial)), + ("x_point_segment", &format!("\"{}\"", spec.x_point.segment)), + ("x_point_length", &format!("\"{}\"", spec.x_point.length)), + ("x_point_order", &format!("\"{}\"", spec.x_point.order)), + ("y_point_segment", &format!("\"{}\"", spec.y_point.segment)), + ("y_point_length", &format!("\"{}\"", spec.y_point.length)), + ("y_point_order", &format!("\"{}\"", spec.y_point.order)), ], - &[local_point, opening_point], + &[x_point, y_point], &["!field.scalar"], )?; - first_result(op, "piop.sumcheck_output_value") + first_result(op, "piop.structured_polynomial_eval") } pub(crate) fn append_sumcheck_output_claim<'c, 'a>( @@ -100,12 +82,12 @@ pub(crate) fn append_sumcheck_output_claim<'c, 'a>( module: &'a BoltModule<'c, Protocol>, spec: OutputClaimSpec<'_>, claim_value: Value<'c, 'a>, - local_values: &[(&str, Value<'c, 'a>)], + polynomial_evals: &[(&str, Value<'c, 'a>)], ) -> Result<(), MlirError> { - let mut operands = Vec::with_capacity(local_values.len() + 1); + let mut operands = Vec::with_capacity(polynomial_evals.len() + 1); operands.push(claim_value); - operands.extend(local_values.iter().map(|(_, value)| *value)); - let local_value_symbols = local_values + operands.extend(polynomial_evals.iter().map(|(_, value)| *value)); + let local_value_symbols = polynomial_evals .iter() .map(|(symbol, _)| *symbol) .collect::>(); @@ -116,8 +98,8 @@ pub(crate) fn append_sumcheck_output_claim<'c, 'a>( &[ ("stage", &format!("@{}", spec.stage)), ("relation", &format!("@{}", spec.relation)), - ("count", &int_attr(local_values.len())), - ("local_values", &symbol_array_attr(&local_value_symbols)), + ("count", &int_attr(polynomial_evals.len())), + ("polynomial_evals", &symbol_array_attr(&local_value_symbols)), ], &operands, &[], diff --git a/crates/bolt/src/schema.rs b/crates/bolt/src/schema.rs index fd1f17b4ec..93824d21be 100644 --- a/crates/bolt/src/schema.rs +++ b/crates/bolt/src/schema.rs @@ -14,15 +14,15 @@ use crate::ir::{ use crate::mlir::MlirError; use crate::pass::{verify_concrete_transcript, VerifyError}; -const SUMCHECK_OUTPUT_VALUE_ATTRS: &[&str] = &[ +const STRUCTURED_POLYNOMIAL_EVAL_ATTRS: &[&str] = &[ "sym_name", - "kind", - "local_point_segment", - "local_point_length", - "local_point_order", - "opening_point_segment", - "opening_point_length", - "opening_point_order", + "polynomial", + "x_point_segment", + "x_point_length", + "x_point_order", + "y_point_segment", + "y_point_length", + "y_point_order", ]; #[derive(Clone, Debug, PartialEq, Eq)] @@ -373,15 +373,15 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( )?; require_shape(operation, 2, 2) } - "piop.sumcheck_output_value" => { - require_attrs(operation, SUMCHECK_OUTPUT_VALUE_ATTRS)?; + "piop.structured_polynomial_eval" => { + require_attrs(operation, STRUCTURED_POLYNOMIAL_EVAL_ATTRS)?; require_shape(operation, 2, 1)?; - require_sumcheck_output_value(operation) + require_structured_polynomial_eval(operation) } "piop.sumcheck_output_claim" => { require_attrs( operation, - &["sym_name", "stage", "relation", "count", "local_values"], + &["sym_name", "stage", "relation", "count", "polynomial_evals"], )?; require_min_shape(operation, 1, 0)?; require_sumcheck_output_claim(operation) @@ -730,15 +730,15 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( )?; require_shape(operation, 2, 2) } - "compute.sumcheck_output_value" => { - require_attrs(operation, SUMCHECK_OUTPUT_VALUE_ATTRS)?; + "compute.structured_polynomial_eval" => { + require_attrs(operation, STRUCTURED_POLYNOMIAL_EVAL_ATTRS)?; require_shape(operation, 2, 1)?; - require_sumcheck_output_value(operation) + require_structured_polynomial_eval(operation) } "compute.sumcheck_output_claim" => { require_attrs( operation, - &["sym_name", "stage", "relation", "count", "local_values"], + &["sym_name", "stage", "relation", "count", "polynomial_evals"], )?; require_min_shape(operation, 1, 0)?; require_sumcheck_output_claim(operation) @@ -1070,15 +1070,15 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( )?; require_shape(operation, 2, 2) } - "cpu.sumcheck_output_value" => { - require_attrs(operation, SUMCHECK_OUTPUT_VALUE_ATTRS)?; + "cpu.structured_polynomial_eval" => { + require_attrs(operation, STRUCTURED_POLYNOMIAL_EVAL_ATTRS)?; require_shape(operation, 2, 1)?; - require_sumcheck_output_value(operation) + require_structured_polynomial_eval(operation) } "cpu.sumcheck_output_claim" => { require_attrs( operation, - &["sym_name", "stage", "relation", "count", "local_values"], + &["sym_name", "stage", "relation", "count", "polynomial_evals"], )?; require_min_shape(operation, 1, 0)?; require_sumcheck_output_claim(operation) @@ -1208,20 +1208,20 @@ fn require_opening_claim_equality(operation: OperationRef<'_, '_>) -> Result<(), Ok(()) } -fn require_sumcheck_output_value(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> { - let kind = string_attr(operation, "kind")?; - if !matches!(kind.as_str(), "eq_mle" | "eq_plus_one" | "lt") { +fn require_structured_polynomial_eval(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> { + let polynomial = string_attr(operation, "polynomial")?; + if !matches!(polynomial.as_str(), "eq" | "eq_plus_one" | "lt") { return Err(SchemaError::new(format!( - "{} attr `kind` has unsupported output value kind `{kind}`", + "{} attr `polynomial` has unsupported structured polynomial `{polynomial}`", operation_name(operation) ))); } - require_sumcheck_output_point_attrs(operation, "local_point")?; - require_sumcheck_output_point_attrs(operation, "opening_point")?; + require_structured_polynomial_point_attrs(operation, "x_point")?; + require_structured_polynomial_point_attrs(operation, "y_point")?; Ok(()) } -fn require_sumcheck_output_point_attrs( +fn require_structured_polynomial_point_attrs( operation: OperationRef<'_, '_>, prefix: &str, ) -> Result<(), SchemaError> { @@ -1235,7 +1235,7 @@ fn require_sumcheck_output_point_attrs( } let length_attr = format!("{prefix}_length"); let length = string_attr(operation, &length_attr)?; - if !matches!(length.as_str(), "full" | "local_point" | "opening_point") { + if !matches!(length.as_str(), "full" | "x_point" | "y_point") { return Err(SchemaError::new(format!( "{} attr `{length_attr}` has unsupported output point length `{length}`", operation_name(operation) @@ -1260,12 +1260,12 @@ fn require_sumcheck_output_point_attrs( fn require_sumcheck_output_claim(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> { let count = int_attr(operation, "count")?; - let local_values = symbol_array_attr(operation, "local_values")?; - if local_values.len() != count { + let polynomial_evals = symbol_array_attr(operation, "polynomial_evals")?; + if polynomial_evals.len() != count { return Err(SchemaError::new(format!( - "{} attr `local_values` length {} does not match count {count}", + "{} attr `polynomial_evals` length {} does not match count {count}", operation_name(operation), - local_values.len() + polynomial_evals.len() ))); } let dynamic_count = operation.operand_count().saturating_sub(1); @@ -1275,7 +1275,7 @@ fn require_sumcheck_output_claim(operation: OperationRef<'_, '_>) -> Result<(), operation_name(operation) ))); } - for (index, expected) in local_values.iter().enumerate() { + for (index, expected) in polynomial_evals.iter().enumerate() { let operand_index = index + 1; let actual = operand_owner_symbol(operation, operand_index)?; if &actual != expected { diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index a5ecaa79f1..9b4b7813ae 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -303,14 +303,14 @@ fn generated_opening_equality_mode(value: &str) -> bolt_verifier_runtime::Openin clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" )] -fn generated_sumcheck_output_value_kind( +fn generated_structured_polynomial_kind( value: &str, -) -> bolt_verifier_runtime::SumcheckOutputValueKind { +) -> bolt_verifier_runtime::StructuredPolynomialKind { match value { - "eq_mle" => bolt_verifier_runtime::SumcheckOutputValueKind::EqMle, - "eq_plus_one" => bolt_verifier_runtime::SumcheckOutputValueKind::EqPlusOne, - "lt" => bolt_verifier_runtime::SumcheckOutputValueKind::Lt, - value => panic!("unsupported generated sumcheck output value kind `{value}`"), + "eq" => bolt_verifier_runtime::StructuredPolynomialKind::Eq, + "eq_plus_one" => bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, + "lt" => bolt_verifier_runtime::StructuredPolynomialKind::Lt, + value => panic!("unsupported generated structured polynomial `{value}`"), } } @@ -318,14 +318,14 @@ fn generated_sumcheck_output_value_kind( clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" )] -fn generated_sumcheck_output_point_segment( +fn generated_structured_polynomial_point_segment( value: &str, -) -> bolt_verifier_runtime::SumcheckOutputPointSegment { +) -> bolt_verifier_runtime::StructuredPolynomialPointSegment { match value { - "full" => bolt_verifier_runtime::SumcheckOutputPointSegment::Full, - "prefix" => bolt_verifier_runtime::SumcheckOutputPointSegment::Prefix, - "suffix" => bolt_verifier_runtime::SumcheckOutputPointSegment::Suffix, - value => panic!("unsupported generated sumcheck output point segment `{value}`"), + "full" => bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, + "prefix" => bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, + "suffix" => bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, + value => panic!("unsupported generated structured polynomial point segment `{value}`"), } } @@ -333,14 +333,14 @@ fn generated_sumcheck_output_point_segment( clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" )] -fn generated_sumcheck_output_point_length( +fn generated_structured_polynomial_point_length( value: &str, -) -> bolt_verifier_runtime::SumcheckOutputPointLength { +) -> bolt_verifier_runtime::StructuredPolynomialPointLength { match value { - "full" => bolt_verifier_runtime::SumcheckOutputPointLength::Full, - "local_point" => bolt_verifier_runtime::SumcheckOutputPointLength::LocalPoint, - "opening_point" => bolt_verifier_runtime::SumcheckOutputPointLength::OpeningPoint, - value => panic!("unsupported generated sumcheck output point length `{value}`"), + "full" => bolt_verifier_runtime::StructuredPolynomialPointLength::Full, + "x_point" => bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, + "y_point" => bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, + value => panic!("unsupported generated structured polynomial point length `{value}`"), } } @@ -348,13 +348,13 @@ fn generated_sumcheck_output_point_length( clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" )] -fn generated_sumcheck_output_point_order( +fn generated_structured_polynomial_point_order( value: &str, -) -> bolt_verifier_runtime::SumcheckOutputPointOrder { +) -> bolt_verifier_runtime::StructuredPolynomialPointOrder { match value { - "as_is" => bolt_verifier_runtime::SumcheckOutputPointOrder::AsIs, - "reverse" => bolt_verifier_runtime::SumcheckOutputPointOrder::Reverse, - value => panic!("unsupported generated sumcheck output point order `{value}`"), + "as_is" => bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs, + "reverse" => bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse, + value => panic!("unsupported generated structured polynomial point order `{value}`"), } } @@ -585,23 +585,23 @@ macro_rules! define_stage_adapter_impl { .iter() .map(|plan| $module::$output_claim { relation: super::generated_relation_kind(&plan.relation), - local_values: super::leak_slice( - plan.local_values + polynomial_evals: super::leak_slice( + plan.polynomial_evals .iter() .map(|value| $module::$output_value { symbol: super::leak_str(&value.symbol), - kind: super::generated_sumcheck_output_value_kind(&value.kind), - local_point: bolt_verifier_runtime::SumcheckOutputPointPlan { - source: super::leak_str(&value.local_point.source), - segment: super::generated_sumcheck_output_point_segment(&value.local_point.segment), - length: super::generated_sumcheck_output_point_length(&value.local_point.length), - order: super::generated_sumcheck_output_point_order(&value.local_point.order), + polynomial: super::generated_structured_polynomial_kind(&value.polynomial), + x_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { + source: super::leak_str(&value.x_point.source), + segment: super::generated_structured_polynomial_point_segment(&value.x_point.segment), + length: super::generated_structured_polynomial_point_length(&value.x_point.length), + order: super::generated_structured_polynomial_point_order(&value.x_point.order), }, - opening_point: bolt_verifier_runtime::SumcheckOutputPointPlan { - source: super::leak_str(&value.opening_point.source), - segment: super::generated_sumcheck_output_point_segment(&value.opening_point.segment), - length: super::generated_sumcheck_output_point_length(&value.opening_point.length), - order: super::generated_sumcheck_output_point_order(&value.opening_point.order), + y_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { + source: super::leak_str(&value.y_point.source), + segment: super::generated_structured_polynomial_point_segment(&value.y_point.segment), + length: super::generated_structured_polynomial_point_length(&value.y_point.length), + order: super::generated_structured_polynomial_point_order(&value.y_point.order), }, }) .collect(), diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs index 5de0452d48..2964ce15c1 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs @@ -23,6 +23,6 @@ define_stage_adapter_no_absorb!( Stage3OpeningClaimPlan, Stage3OpeningBatchPlan, output_claims = Stage3SumcheckOutputClaimPlan, - output_values = Stage3SumcheckOutputValuePlan, + output_values = Stage3StructuredPolynomialEvalPlan, opening_equalities = Stage3OpeningClaimEqualityPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs index ae92aafe21..05273e588a 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs @@ -26,5 +26,5 @@ define_stage_adapter!( Stage4OpeningClaimEqualityPlan, Stage4OpeningBatchPlan, output_claims = Stage4SumcheckOutputClaimPlan, - output_values = Stage4SumcheckOutputValuePlan + output_values = Stage4StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index d9fe65028a..d1935174eb 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -18,7 +18,7 @@ pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage3SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; -pub type Stage3SumcheckOutputValuePlan = bolt_verifier_runtime::SumcheckOutputValuePlan; +pub type Stage3StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind; pub use bolt_verifier_runtime::{ @@ -33,11 +33,11 @@ pub use bolt_verifier_runtime::{ ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, - SumcheckOutputPointLength as Stage3SumcheckOutputPointLength, - SumcheckOutputPointOrder as Stage3SumcheckOutputPointOrder, - SumcheckOutputPointPlan as Stage3SumcheckOutputPointPlan, - SumcheckOutputPointSegment as Stage3SumcheckOutputPointSegment, - SumcheckOutputValueKind as Stage3SumcheckOutputValueKind, + StructuredPolynomialPointLength as Stage3StructuredPolynomialPointLength, + StructuredPolynomialPointOrder as Stage3StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan as Stage3StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment as Stage3StructuredPolynomialPointSegment, + StructuredPolynomialKind as Stage3StructuredPolynomialKind, TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, }; @@ -210,23 +210,23 @@ pub const STAGE3_OPENING_EQUALITIES: &[Stage3OpeningClaimEqualityPlan] = &[ pub const STAGE3_OPENING_BATCHES: &[Stage3OpeningBatchPlan] = &[ Stage3OpeningBatchPlan { symbol: "stage3.openings", stage: "stage3", proof_slot: "stage3.openings", policy: "jolt_stage3_output_order", count: 16, ordered_claims: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"], claim_operands: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"] }, ]; -pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage3SumcheckOutputValuePlan] = &[ - Stage3SumcheckOutputValuePlan { symbol: "stage3.spartan_shift.output.eq.NextPC", kind: Stage3SumcheckOutputValueKind::EqPlusOne, local_point: Stage3SumcheckOutputPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::Reverse }, opening_point: Stage3SumcheckOutputPointPlan { source: "stage3.input.stage1.NextPC", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::AsIs } }, - Stage3SumcheckOutputValuePlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", kind: Stage3SumcheckOutputValueKind::EqPlusOne, local_point: Stage3SumcheckOutputPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::Reverse }, opening_point: Stage3SumcheckOutputPointPlan { source: "stage3.input.stage2.product_virtual.NextIsNoop", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::AsIs } }, +pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ + Stage3StructuredPolynomialEvalPlan { symbol: "stage3.spartan_shift.output.eq.NextPC", polynomial: Stage3StructuredPolynomialKind::EqPlusOne, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage1.NextPC", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, + Stage3StructuredPolynomialEvalPlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", polynomial: Stage3StructuredPolynomialKind::EqPlusOne, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage2.product_virtual.NextIsNoop", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage3SumcheckOutputValuePlan] = &[ - Stage3SumcheckOutputValuePlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", kind: Stage3SumcheckOutputValueKind::EqMle, local_point: Stage3SumcheckOutputPointPlan { source: "stage3.instruction_input.instance", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::Reverse }, opening_point: Stage3SumcheckOutputPointPlan { source: "stage3.input.stage2.product_virtual.LeftInstructionInput", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::AsIs } }, +pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ + Stage3StructuredPolynomialEvalPlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", polynomial: Stage3StructuredPolynomialKind::Eq, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.instruction_input.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage2.product_virtual.LeftInstructionInput", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage3SumcheckOutputValuePlan] = &[ - Stage3SumcheckOutputValuePlan { symbol: "stage3.registers.output.eq.RdWriteValue", kind: Stage3SumcheckOutputValueKind::EqMle, local_point: Stage3SumcheckOutputPointPlan { source: "stage3.registers_claim_reduction.instance", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::Reverse }, opening_point: Stage3SumcheckOutputPointPlan { source: "stage3.input.stage1.RdWriteValue", segment: Stage3SumcheckOutputPointSegment::Full, length: Stage3SumcheckOutputPointLength::Full, order: Stage3SumcheckOutputPointOrder::AsIs } }, +pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ + Stage3StructuredPolynomialEvalPlan { symbol: "stage3.registers.output.eq.RdWriteValue", polynomial: Stage3StructuredPolynomialKind::Eq, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.registers_claim_reduction.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage1.RdWriteValue", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, ]; pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[ - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, local_values: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage3.spartan_shift.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, local_values: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage3.instruction_input.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, local_values: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, claim_value: "stage3.registers.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage3.spartan_shift.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage3.instruction_input.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, claim_value: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 28e5af6ef5..a2faa80612 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -16,7 +16,7 @@ pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage4SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; -pub type Stage4SumcheckOutputValuePlan = bolt_verifier_runtime::SumcheckOutputValuePlan; +pub type Stage4StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind; pub use bolt_verifier_runtime::{ @@ -32,11 +32,11 @@ pub use bolt_verifier_runtime::{ ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, SumcheckBatchPlan as Stage4SumcheckBatchPlan, SumcheckEvalPlan as Stage4SumcheckEvalPlan, - SumcheckOutputPointLength as Stage4SumcheckOutputPointLength, - SumcheckOutputPointOrder as Stage4SumcheckOutputPointOrder, - SumcheckOutputPointPlan as Stage4SumcheckOutputPointPlan, - SumcheckOutputPointSegment as Stage4SumcheckOutputPointSegment, - SumcheckOutputValueKind as Stage4SumcheckOutputValueKind, + StructuredPolynomialPointLength as Stage4StructuredPolynomialPointLength, + StructuredPolynomialPointOrder as Stage4StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan as Stage4StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment as Stage4StructuredPolynomialPointSegment, + StructuredPolynomialKind as Stage4StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage4TranscriptSqueezeKind, TranscriptSqueezePlan as Stage4TranscriptSqueezePlan, @@ -174,17 +174,17 @@ pub const STAGE4_OPENING_EQUALITIES: &[Stage4OpeningClaimEqualityPlan] = &[ pub const STAGE4_OPENING_BATCHES: &[Stage4OpeningBatchPlan] = &[ Stage4OpeningBatchPlan { symbol: "stage4.openings", stage: "stage4", proof_slot: "stage4.openings", policy: "jolt_stage4_output_order", count: 7, ordered_claims: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"], claim_operands: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"] }, ]; -pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage4SumcheckOutputValuePlan] = &[ - Stage4SumcheckOutputValuePlan { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", kind: Stage4SumcheckOutputValueKind::EqMle, local_point: Stage4SumcheckOutputPointPlan { source: "stage4.registers_read_write.instance", segment: Stage4SumcheckOutputPointSegment::Prefix, length: Stage4SumcheckOutputPointLength::OpeningPoint, order: Stage4SumcheckOutputPointOrder::Reverse }, opening_point: Stage4SumcheckOutputPointPlan { source: "stage4.input.stage3.registers.RdWriteValue", segment: Stage4SumcheckOutputPointSegment::Full, length: Stage4SumcheckOutputPointLength::Full, order: Stage4SumcheckOutputPointOrder::AsIs } }, +pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage4StructuredPolynomialEvalPlan] = &[ + Stage4StructuredPolynomialEvalPlan { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", polynomial: Stage4StructuredPolynomialKind::Eq, x_point: Stage4StructuredPolynomialPointPlan { source: "stage4.registers_read_write.instance", segment: Stage4StructuredPolynomialPointSegment::Prefix, length: Stage4StructuredPolynomialPointLength::YPoint, order: Stage4StructuredPolynomialPointOrder::Reverse }, y_point: Stage4StructuredPolynomialPointPlan { source: "stage4.input.stage3.registers.RdWriteValue", segment: Stage4StructuredPolynomialPointSegment::Full, length: Stage4StructuredPolynomialPointLength::Full, order: Stage4StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage4SumcheckOutputValuePlan] = &[ - Stage4SumcheckOutputValuePlan { symbol: "stage4.ram_val_check.output.lt.RamValCycle", kind: Stage4SumcheckOutputValueKind::Lt, local_point: Stage4SumcheckOutputPointPlan { source: "stage4.ram_val_check.instance", segment: Stage4SumcheckOutputPointSegment::Full, length: Stage4SumcheckOutputPointLength::Full, order: Stage4SumcheckOutputPointOrder::Reverse }, opening_point: Stage4SumcheckOutputPointPlan { source: "stage4.input.stage2.RamVal", segment: Stage4SumcheckOutputPointSegment::Suffix, length: Stage4SumcheckOutputPointLength::LocalPoint, order: Stage4SumcheckOutputPointOrder::AsIs } }, +pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage4StructuredPolynomialEvalPlan] = &[ + Stage4StructuredPolynomialEvalPlan { symbol: "stage4.ram_val_check.output.lt.RamValCycle", polynomial: Stage4StructuredPolynomialKind::Lt, x_point: Stage4StructuredPolynomialPointPlan { source: "stage4.ram_val_check.instance", segment: Stage4StructuredPolynomialPointSegment::Full, length: Stage4StructuredPolynomialPointLength::Full, order: Stage4StructuredPolynomialPointOrder::Reverse }, y_point: Stage4StructuredPolynomialPointPlan { source: "stage4.input.stage2.RamVal", segment: Stage4StructuredPolynomialPointSegment::Suffix, length: Stage4StructuredPolynomialPointLength::XPoint, order: Stage4StructuredPolynomialPointOrder::AsIs } }, ]; pub const STAGE4_SUMCHECK_OUTPUT_CLAIMS: &[Stage4SumcheckOutputClaimPlan] = &[ - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, local_values: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage4.registers_read_write.output.claim_expr" }, - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, local_values: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage4.ram_val_check.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage4.registers_read_write.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { From 2e0f1b15176b075ea7acd64c19d8eddc1a5dd461 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 15:13:11 -0600 Subject: [PATCH 027/171] refactor(bolt): lift stage output claims Move Stage 5 RAM/register and Stage 6 Eq-shaped verifier output claim formulas into typed protocol-owned output claim plans. Regenerate the verifier/equivalence role crates and update focused commitment IR assertions for the new plan surface. --- crates/bolt-verifier-runtime/src/lib.rs | 1 + .../src/protocols/jolt/emit/rust/stage5.rs | 468 ++++++++++++++--- .../src/protocols/jolt/emit/rust/stage6.rs | 469 ++++++++++++++++-- .../src/protocols/jolt/emit/rust/stage7.rs | 6 + .../bolt/src/protocols/jolt/phases/stage5.rs | 184 ++++++- .../bolt/src/protocols/jolt/phases/stage6.rs | 453 ++++++++++++++++- crates/bolt/tests/commitment_ir.rs | 59 ++- .../src/plan_adapters/generated_stage5.rs | 3 +- .../src/plan_adapters/generated_stage6.rs | 4 +- .../src/plan_adapters/generated_stage7.rs | 3 +- crates/jolt-verifier/src/stages/stage5.rs | 116 +++-- crates/jolt-verifier/src/stages/stage6.rs | 123 +++-- crates/jolt-verifier/src/stages/stage7.rs | 1 + 13 files changed, 1671 insertions(+), 219 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 16bca14352..09e4b0a0d4 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -446,6 +446,7 @@ pub struct StageProgramPlan { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], + pub output_claims: &'static [SumcheckOutputClaimPlan], pub point_zeros: &'static [PointZeroPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 49d8073c3f..f4c5a66fbe 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -29,6 +29,8 @@ pub struct Stage5CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, + pub output_values: Vec, + pub output_claims: Vec, pub point_slices: Vec, pub point_concats: Vec, pub opening_claims: Vec, @@ -167,6 +169,37 @@ pub struct Stage5SumcheckEvalPlan { pub oracle: String, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage5StructuredPolynomialPointPlan { + pub source: String, + pub segment: String, + pub length: String, + pub order: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage5StructuredPolynomialEvalPlan { + pub symbol: String, + pub polynomial: String, + pub x_point: Stage5StructuredPolynomialPointPlan, + pub y_point: Stage5StructuredPolynomialPointPlan, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage5SumcheckOutputClaimPlan { + pub relation: String, + pub polynomial_evals: Vec, + pub claim_value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct Stage5SumcheckOutputClaimAst { + relation: String, + polynomial_evals: Vec, + polynomial_eval_operands: Vec, + claim_value: String, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5PointSlicePlan { pub symbol: String, @@ -245,6 +278,8 @@ impl Stage5CpuProgram { let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); + let mut output_values = Vec::new(); + let mut output_claim_asts = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); let mut opening_claims = Vec::new(); @@ -456,6 +491,32 @@ impl Stage5CpuProgram { oracle: symbol_attr(op, "oracle")?, }); } + "cpu.structured_polynomial_eval" => { + output_values.push(Stage5StructuredPolynomialEvalPlan { + symbol: string_attr(op, "sym_name")?, + polynomial: string_attr(op, "polynomial")?, + x_point: Stage5StructuredPolynomialPointPlan { + source: operand_symbol(op, 0)?, + segment: string_attr(op, "x_point_segment")?, + length: string_attr(op, "x_point_length")?, + order: string_attr(op, "x_point_order")?, + }, + y_point: Stage5StructuredPolynomialPointPlan { + source: operand_symbol(op, 1)?, + segment: string_attr(op, "y_point_segment")?, + length: string_attr(op, "y_point_length")?, + order: string_attr(op, "y_point_order")?, + }, + }); + } + "cpu.sumcheck_output_claim" => { + output_claim_asts.push(Stage5SumcheckOutputClaimAst { + relation: symbol_attr(op, "relation")?, + claim_value: operand_symbol(op, 0)?, + polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, + polynomial_eval_operands: operand_symbols(op, 1)?, + }); + } "cpu.point_slice" => { point_slices.push(Stage5PointSlicePlan { symbol: string_attr(op, "sym_name")?, @@ -507,11 +568,21 @@ impl Stage5CpuProgram { } } + let role = module + .role() + .ok_or_else(|| EmitError::new("missing cpu party role"))?; + if role == Role::Prover { + prune_prover_output_field_exprs(&mut field_exprs, &claims, &output_claim_asts); + } + let output_claims = if role == Role::Verifier { + resolve_stage5_output_claims(&output_values, output_claim_asts)? + } else { + Vec::new() + }; + Ok(Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, - role: module - .role() - .ok_or_else(|| EmitError::new("missing cpu party role"))?, + role, steps, transcript_squeezes, transcript_absorb_bytes, @@ -524,6 +595,8 @@ impl Stage5CpuProgram { drivers, instance_results, evals, + output_values, + output_claims, point_slices, point_concats, opening_claims, @@ -546,6 +619,9 @@ impl Stage5CpuProgram { } Role::Verifier => self.verify_verifier_driver_bindings()?, } + if self.role == Role::Verifier { + self.verify_output_claims()?; + } self.verify_opening_flow() } @@ -621,6 +697,9 @@ impl Stage5CpuProgram { .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), )); + values.extend(symbols( + self.output_values.iter().map(|value| &value.symbol), + )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); values @@ -799,6 +878,75 @@ impl Stage5CpuProgram { Ok(()) } + fn verify_output_claims(&self) -> Result<(), EmitError> { + let relations = symbols( + self.instance_results + .iter() + .map(|instance| &instance.relation), + ); + let field_values = self.field_value_symbols(); + let mut point_values = symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + ); + point_values.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_values.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + for polynomial_eval in &self.output_values { + if !point_values.contains(&polynomial_eval.x_point.source) { + return Err(EmitError::new(format!( + "stage5 structured polynomial eval @{} references missing x-point @{}", + polynomial_eval.symbol, polynomial_eval.x_point.source + ))); + } + if !point_values.contains(&polynomial_eval.y_point.source) { + return Err(EmitError::new(format!( + "stage5 structured polynomial eval @{} references missing y-point @{}", + polynomial_eval.symbol, polynomial_eval.y_point.source + ))); + } + if !matches!( + polynomial_eval.polynomial.as_str(), + "eq" | "eq_plus_one" | "lt" + ) { + return Err(EmitError::new(format!( + "stage5 structured polynomial eval @{} has unsupported polynomial `{}`", + polynomial_eval.symbol, polynomial_eval.polynomial + ))); + } + verify_structured_polynomial_point_plan( + "stage5", + polynomial_eval, + &polynomial_eval.x_point, + )?; + verify_structured_polynomial_point_plan( + "stage5", + polynomial_eval, + &polynomial_eval.y_point, + )?; + } + for claim in &self.output_claims { + if !relations.contains(&claim.relation) { + return Err(EmitError::new(format!( + "stage5 output claim references missing relation @{}", + claim.relation + ))); + } + if !field_values.contains(&claim.claim_value) { + return Err(EmitError::new(format!( + "stage5 output claim for @{} uses missing claim value @{}", + claim.relation, claim.claim_value + ))); + } + } + Ok(()) + } + fn verify_opening_flow(&self) -> Result<(), EmitError> { let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); point_sources.extend(symbols( @@ -963,9 +1111,9 @@ impl Stage5CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice, suffix_point};\n\ - use super::jolt_relations::{identity_polynomial_eval, lt_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval};\n\ - use jolt_field::{Field, Fr, RingCore};\n\ + "use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice};\n\ + use super::jolt_relations::{identity_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval};\n\ + use jolt_field::{Field, Fr};\n\ use jolt_lookup_tables::LookupTableKind;\n\ use jolt_poly::EqPolynomial;\n\ use jolt_sumcheck::SumcheckError;\n\ @@ -1188,6 +1336,8 @@ pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZe pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage5SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage5SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage5StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage5RelationKind; pub use bolt_verifier_runtime::{ @@ -1203,6 +1353,11 @@ pub use bolt_verifier_runtime::{ ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params, SumcheckBatchPlan as Stage5SumcheckBatchPlan, SumcheckEvalPlan as Stage5SumcheckEvalPlan, + StructuredPolynomialPointLength as Stage5StructuredPolynomialPointLength, + StructuredPolynomialPointOrder as Stage5StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment as Stage5StructuredPolynomialPointSegment, + StructuredPolynomialKind as Stage5StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage5TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage5TranscriptSqueezeKind, TranscriptSqueezePlan as Stage5TranscriptSqueezePlan, @@ -1243,8 +1398,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); + if self.role == Role::Verifier { + source.push_str(&self.emit_verifier_output_claim_constants()?); + } let output_claims_field = if self.role == Role::Verifier { - " output_claims: &[],\n" + " output_claims: STAGE5_SUMCHECK_OUTPUT_CLAIMS,\n" } else { "" }; @@ -1739,6 +1897,47 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); format!("pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[\n{evals}\n];\n\n") } + fn emit_verifier_output_claim_constants(&self) -> Result { + let mut source = String::new(); + let mut claims = Vec::new(); + for (index, claim) in self.output_claims.iter().enumerate() { + let values_name = format!("STAGE5_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES"); + let values = claim + .polynomial_evals + .iter() + .map(|value| { + Ok(format!( + " Stage5StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", + rust_str(&value.symbol), + stage5_structured_polynomial_kind_expr(&value.polynomial)?, + stage5_structured_polynomial_point_expr(&value.x_point)?, + stage5_structured_polynomial_point_expr(&value.y_point)?, + )) + }) + .collect::, EmitError>>()? + .join("\n"); + push_format( + &mut source, + format_args!( + "pub const {values_name}: &[Stage5StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" + ), + ); + claims.push(format!( + " Stage5SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, claim_value: {} }},", + super::plan_tokens::role_relation_kind_expr("Stage5", &self.role, &claim.relation)?, + rust_str(&claim.claim_value) + )); + } + let claims = claims.join("\n"); + push_format( + &mut source, + format_args!( + "pub const STAGE5_SUMCHECK_OUTPUT_CLAIMS: &[Stage5SumcheckOutputClaimPlan] = &[\n{claims}\n];\n\n" + ), + ); + Ok(source) + } + fn emit_point_slice_constants(&self) -> String { let slices = self .point_slices @@ -2195,10 +2394,38 @@ fn expected_batched_output_claim( expected_instruction_read_raf(store, evals, local_point)? } Stage5RelationKind::Stage5RamRaClaimReduction => { - expected_ram_ra_claim_reduction(store, evals, local_point)? + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage5Error::UnsupportedRelation { + relation: instance.relation, + })?; + bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )? } Stage5RelationKind::Stage5RegistersValEvaluation => { - expected_registers_val_evaluation(store, evals, local_point)? + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage5Error::UnsupportedRelation { + relation: instance.relation, + })?; + bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )? } relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }), }; @@ -2265,53 +2492,6 @@ fn expected_instruction_read_raf( Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim)) } -fn expected_ram_ra_claim_reduction( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage5NamedEval], - local_point: &[Fr], -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let r_cycle_raf = suffix_point( - bolt_verifier_runtime::store_point(store, "stage5.input.stage2.ram_raf.RamRa")?, - r_cycle_reduced.len(), - "stage5.input.stage2.ram_raf.RamRa", - )?; - let r_cycle_rw = suffix_point( - bolt_verifier_runtime::store_point(store, "stage5.input.stage2.ram_read_write.RamRa")?, - r_cycle_reduced.len(), - "stage5.input.stage2.ram_read_write.RamRa", - )?; - let r_cycle_val = suffix_point( - bolt_verifier_runtime::store_point(store, "stage5.input.stage4.ram_val_check.RamRa")?, - r_cycle_reduced.len(), - "stage5.input.stage4.ram_val_check.RamRa", - )?; - let gamma = bolt_verifier_runtime::store_scalar(store, "stage5.ram_ra_claim_reduction.gamma")?; - let eq_combined = EqPolynomial::::mle(r_cycle_raf, &r_cycle_reduced) - + gamma * EqPolynomial::::mle(r_cycle_rw, &r_cycle_reduced) - + gamma.square() * EqPolynomial::::mle(r_cycle_val, &r_cycle_reduced); - let ram_ra = eval_by_name(evals, "stage5.ram_ra_claim_reduction.eval.RamRa")?; - Ok(eq_combined * ram_ra) -} - -fn expected_registers_val_evaluation( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage5NamedEval], - local_point: &[Fr], -) -> Result { - let registers_val_point = bolt_verifier_runtime::store_point(store, "stage5.input.stage4.registers.RegistersVal")?; - let r_cycle = suffix_point( - registers_val_point, - local_point.len(), - "stage5.input.stage4.registers.RegistersVal", - )?; - let r_reduced = reverse_slice(local_point); - let lt_eval = lt_polynomial_eval(&r_reduced, r_cycle); - let rd_inc = eval_by_name(evals, "stage5.registers_val_evaluation.eval.RdInc")?; - let rd_wa = eval_by_name(evals, "stage5.registers_val_evaluation.eval.RdWa")?; - Ok(rd_inc * rd_wa * lt_eval) -} - "# } } @@ -2342,6 +2522,182 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } +fn resolve_stage5_output_claims( + output_values: &[Stage5StructuredPolynomialEvalPlan], + claim_asts: Vec, +) -> Result, EmitError> { + let output_values_by_symbol: BTreeMap<_, _> = output_values + .iter() + .map(|value| (value.symbol.as_str(), value)) + .collect(); + claim_asts + .into_iter() + .map(|claim| { + verify_count( + "sumcheck output claim polynomial_evals", + &claim.relation, + claim.polynomial_evals.len(), + claim.polynomial_eval_operands.len(), + )?; + if claim.polynomial_evals != claim.polynomial_eval_operands { + return Err(EmitError::new(format!( + "stage5 output claim for @{} polynomial_evals do not match operands", + claim.relation + ))); + } + let polynomial_evals = claim + .polynomial_evals + .iter() + .map(|symbol| { + output_values_by_symbol + .get(symbol.as_str()) + .copied() + .cloned() + .ok_or_else(|| { + EmitError::new(format!( + "stage5 output claim for @{} references missing output value @{symbol}", + claim.relation + )) + }) + }) + .collect::, EmitError>>()?; + Ok(Stage5SumcheckOutputClaimPlan { + relation: claim.relation, + polynomial_evals, + claim_value: claim.claim_value, + }) + }) + .collect() +} + +fn prune_prover_output_field_exprs( + field_exprs: &mut Vec, + claims: &[Stage5SumcheckClaimPlan], + output_claims: &[Stage5SumcheckOutputClaimAst], +) { + let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs + .iter() + .map(|expr| (expr.symbol.as_str(), expr)) + .collect(); + let sumcheck_claim_closure = field_expr_dependency_closure( + &field_exprs_by_symbol, + claims.iter().map(|claim| claim.claim_value.as_str()), + ); + let output_claim_closure = field_expr_dependency_closure( + &field_exprs_by_symbol, + output_claims.iter().map(|claim| claim.claim_value.as_str()), + ); + field_exprs.retain(|expr| { + !output_claim_closure.contains(&expr.symbol) + || sumcheck_claim_closure.contains(&expr.symbol) + }); +} + +fn field_expr_dependency_closure<'a>( + field_exprs_by_symbol: &BTreeMap<&str, &Stage5FieldExprPlan>, + roots: impl Iterator, +) -> BTreeSet { + let mut visited = BTreeSet::new(); + let mut stack = roots.map(str::to_owned).collect::>(); + while let Some(symbol) = stack.pop() { + if !visited.insert(symbol.clone()) { + continue; + } + let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { + continue; + }; + for operand in &expr.operands { + if field_exprs_by_symbol.contains_key(operand.as_str()) { + stack.push(operand.clone()); + } + } + } + visited +} + +fn verify_structured_polynomial_point_plan( + stage: &str, + polynomial_eval: &Stage5StructuredPolynomialEvalPlan, + point: &Stage5StructuredPolynomialPointPlan, +) -> Result<(), EmitError> { + if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point segment `{}`", + polynomial_eval.symbol, point.segment + ))); + } + if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point length `{}`", + polynomial_eval.symbol, point.length + ))); + } + if !matches!(point.order.as_str(), "as_is" | "reverse") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point order `{}`", + polynomial_eval.symbol, point.order + ))); + } + Ok(()) +} + +fn stage5_structured_polynomial_kind_expr(polynomial: &str) -> Result<&'static str, EmitError> { + match polynomial { + "eq" => Ok("Stage5StructuredPolynomialKind::Eq"), + "eq_plus_one" => Ok("Stage5StructuredPolynomialKind::EqPlusOne"), + "lt" => Ok("Stage5StructuredPolynomialKind::Lt"), + _ => Err(EmitError::new(format!( + "unsupported stage5 structured polynomial `{polynomial}`" + ))), + } +} + +fn stage5_structured_polynomial_point_expr( + point: &Stage5StructuredPolynomialPointPlan, +) -> Result { + Ok(format!( + "Stage5StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", + rust_str(&point.source), + stage5_structured_polynomial_point_segment_expr(&point.segment)?, + stage5_structured_polynomial_point_length_expr(&point.length)?, + stage5_structured_polynomial_point_order_expr(&point.order)?, + )) +} + +fn stage5_structured_polynomial_point_segment_expr( + segment: &str, +) -> Result<&'static str, EmitError> { + match segment { + "full" => Ok("Stage5StructuredPolynomialPointSegment::Full"), + "prefix" => Ok("Stage5StructuredPolynomialPointSegment::Prefix"), + "suffix" => Ok("Stage5StructuredPolynomialPointSegment::Suffix"), + _ => Err(EmitError::new(format!( + "unsupported stage5 output point segment `{segment}`" + ))), + } +} + +fn stage5_structured_polynomial_point_length_expr(length: &str) -> Result<&'static str, EmitError> { + match length { + "full" => Ok("Stage5StructuredPolynomialPointLength::Full"), + "x_point" => Ok("Stage5StructuredPolynomialPointLength::XPoint"), + "y_point" => Ok("Stage5StructuredPolynomialPointLength::YPoint"), + _ => Err(EmitError::new(format!( + "unsupported stage5 structured polynomial point length `{length}`" + ))), + } +} + +fn stage5_structured_polynomial_point_order_expr(order: &str) -> Result<&'static str, EmitError> { + match order { + "as_is" => Ok("Stage5StructuredPolynomialPointOrder::AsIs"), + "reverse" => Ok("Stage5StructuredPolynomialPointOrder::Reverse"), + _ => Err(EmitError::new(format!( + "unsupported stage5 output point order `{order}`" + ))), + } +} + fn emit_str_array(name: &str, values: &[String]) -> String { if values.is_empty() { return format!("pub const {name}: &[&str] = &[];\n\n"); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index c4920422ca..90cbae5237 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -29,6 +29,8 @@ pub struct Stage6CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, + pub output_values: Vec, + pub output_claims: Vec, pub point_zeros: Vec, pub point_slices: Vec, pub point_concats: Vec, @@ -168,6 +170,37 @@ pub struct Stage6SumcheckEvalPlan { pub oracle: String, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage6StructuredPolynomialPointPlan { + pub source: String, + pub segment: String, + pub length: String, + pub order: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage6StructuredPolynomialEvalPlan { + pub symbol: String, + pub polynomial: String, + pub x_point: Stage6StructuredPolynomialPointPlan, + pub y_point: Stage6StructuredPolynomialPointPlan, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage6SumcheckOutputClaimPlan { + pub relation: String, + pub polynomial_evals: Vec, + pub claim_value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct Stage6SumcheckOutputClaimAst { + relation: String, + polynomial_evals: Vec, + polynomial_eval_operands: Vec, + claim_value: String, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage6PointZeroPlan { pub symbol: String, @@ -253,6 +286,8 @@ impl Stage6CpuProgram { let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); + let mut output_values = Vec::new(); + let mut output_claim_asts = Vec::new(); let mut point_zeros = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); @@ -465,6 +500,32 @@ impl Stage6CpuProgram { oracle: symbol_attr(op, "oracle")?, }); } + "cpu.structured_polynomial_eval" => { + output_values.push(Stage6StructuredPolynomialEvalPlan { + symbol: string_attr(op, "sym_name")?, + polynomial: string_attr(op, "polynomial")?, + x_point: Stage6StructuredPolynomialPointPlan { + source: operand_symbol(op, 0)?, + segment: string_attr(op, "x_point_segment")?, + length: string_attr(op, "x_point_length")?, + order: string_attr(op, "x_point_order")?, + }, + y_point: Stage6StructuredPolynomialPointPlan { + source: operand_symbol(op, 1)?, + segment: string_attr(op, "y_point_segment")?, + length: string_attr(op, "y_point_length")?, + order: string_attr(op, "y_point_order")?, + }, + }); + } + "cpu.sumcheck_output_claim" => { + output_claim_asts.push(Stage6SumcheckOutputClaimAst { + relation: symbol_attr(op, "relation")?, + claim_value: operand_symbol(op, 0)?, + polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, + polynomial_eval_operands: operand_symbols(op, 1)?, + }); + } "cpu.point_zero" => { point_zeros.push(Stage6PointZeroPlan { symbol: string_attr(op, "sym_name")?, @@ -523,11 +584,21 @@ impl Stage6CpuProgram { } } + let role = module + .role() + .ok_or_else(|| EmitError::new("missing cpu party role"))?; + if role == Role::Prover { + prune_prover_output_field_exprs(&mut field_exprs, &claims, &output_claim_asts); + } + let output_claims = if role == Role::Verifier { + resolve_stage6_output_claims(&output_values, output_claim_asts)? + } else { + Vec::new() + }; + Ok(Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, - role: module - .role() - .ok_or_else(|| EmitError::new("missing cpu party role"))?, + role, steps, transcript_squeezes, transcript_absorb_bytes, @@ -540,6 +611,8 @@ impl Stage6CpuProgram { drivers, instance_results, evals, + output_values, + output_claims, point_zeros, point_slices, point_concats, @@ -563,6 +636,9 @@ impl Stage6CpuProgram { } Role::Verifier => self.verify_verifier_driver_bindings()?, } + if self.role == Role::Verifier { + self.verify_output_claims()?; + } self.verify_opening_flow() } @@ -638,6 +714,9 @@ impl Stage6CpuProgram { .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), )); + values.extend(symbols( + self.output_values.iter().map(|value| &value.symbol), + )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); values @@ -819,6 +898,76 @@ impl Stage6CpuProgram { Ok(()) } + fn verify_output_claims(&self) -> Result<(), EmitError> { + let relations = symbols( + self.instance_results + .iter() + .map(|instance| &instance.relation), + ); + let field_values = self.field_value_symbols(); + let mut point_values = symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + ); + point_values.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_values.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); + point_values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_values.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + for polynomial_eval in &self.output_values { + if !point_values.contains(&polynomial_eval.x_point.source) { + return Err(EmitError::new(format!( + "stage6 structured polynomial eval @{} references missing x-point @{}", + polynomial_eval.symbol, polynomial_eval.x_point.source + ))); + } + if !point_values.contains(&polynomial_eval.y_point.source) { + return Err(EmitError::new(format!( + "stage6 structured polynomial eval @{} references missing y-point @{}", + polynomial_eval.symbol, polynomial_eval.y_point.source + ))); + } + if !matches!( + polynomial_eval.polynomial.as_str(), + "eq" | "eq_plus_one" | "lt" + ) { + return Err(EmitError::new(format!( + "stage6 structured polynomial eval @{} has unsupported polynomial `{}`", + polynomial_eval.symbol, polynomial_eval.polynomial + ))); + } + verify_structured_polynomial_point_plan( + "stage6", + polynomial_eval, + &polynomial_eval.x_point, + )?; + verify_structured_polynomial_point_plan( + "stage6", + polynomial_eval, + &polynomial_eval.y_point, + )?; + } + for claim in &self.output_claims { + if !relations.contains(&claim.relation) { + return Err(EmitError::new(format!( + "stage6 output claim references missing relation @{}", + claim.relation + ))); + } + if !field_values.contains(&claim.claim_value) { + return Err(EmitError::new(format!( + "stage6 output claim for @{} uses missing claim value @{}", + claim.relation, claim.claim_value + ))); + } + } + Ok(()) + } + fn verify_opening_flow(&self) -> Result<(), EmitError> { let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); point_sources.extend(symbols( @@ -988,7 +1137,7 @@ impl Stage6CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ - use super::jolt_relations::{expected_stage67_booleanity, expected_stage67_bytecode_read_raf, expected_stage67_hamming_booleanity, expected_stage67_inc_claim_reduction, expected_stage67_instruction_ra_virtual, expected_stage67_ram_ra_virtual, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols};\n\ + use super::jolt_relations::{expected_stage67_booleanity, expected_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -1218,6 +1367,8 @@ pub type Stage6CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage6SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage6SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage6SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage6StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage6RelationKind; pub use bolt_verifier_runtime::{ @@ -1234,6 +1385,11 @@ pub use bolt_verifier_runtime::{ StageParams as Stage6Params, SumcheckBatchPlan as Stage6SumcheckBatchPlan, SumcheckEvalPlan as Stage6SumcheckEvalPlan, + StructuredPolynomialPointLength as Stage6StructuredPolynomialPointLength, + StructuredPolynomialPointOrder as Stage6StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment as Stage6StructuredPolynomialPointSegment, + StructuredPolynomialKind as Stage6StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage6TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage6TranscriptSqueezeKind, TranscriptSqueezePlan as Stage6TranscriptSqueezePlan, @@ -1376,6 +1532,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); + if self.role == Role::Verifier { + source.push_str(&self.emit_verifier_output_claim_constants()?); + } + let output_claims_field = if self.role == Role::Verifier { + " output_claims: STAGE6_SUMCHECK_OUTPUT_CLAIMS,\n" + } else { + "" + }; push_format( &mut source, format_args!( @@ -1394,6 +1558,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); \x20 drivers: STAGE6_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE6_SUMCHECK_EVALS,\n\ + {output_claims_field}\ \x20 point_zeros: STAGE6_POINT_ZEROS,\n\ \x20 point_slices: STAGE6_POINT_SLICES,\n\ \x20 point_concats: STAGE6_POINT_CONCATS,\n\ @@ -1887,6 +2052,47 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); ) } + fn emit_verifier_output_claim_constants(&self) -> Result { + let mut source = String::new(); + let mut claims = Vec::new(); + for (index, claim) in self.output_claims.iter().enumerate() { + let values_name = format!("STAGE6_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES"); + let values = claim + .polynomial_evals + .iter() + .map(|value| { + Ok(format!( + " Stage6StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", + rust_str(&value.symbol), + stage6_structured_polynomial_kind_expr(&value.polynomial)?, + stage6_structured_polynomial_point_expr(&value.x_point)?, + stage6_structured_polynomial_point_expr(&value.y_point)?, + )) + }) + .collect::, EmitError>>()? + .join("\n"); + push_format( + &mut source, + format_args!( + "pub const {values_name}: &[Stage6StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" + ), + ); + claims.push(format!( + " Stage6SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, claim_value: {} }},", + super::plan_tokens::role_relation_kind_expr("Stage6", &self.role, &claim.relation)?, + rust_str(&claim.claim_value) + )); + } + let claims = claims.join("\n"); + push_format( + &mut source, + format_args!( + "pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[\n{claims}\n];\n\n" + ), + ); + Ok(source) + } + fn emit_point_zero_constants(&self) -> String { let zeros = self .point_zeros @@ -2393,18 +2599,16 @@ fn expected_batched_output_claim( Stage6RelationKind::Stage6Booleanity => { expected_booleanity(program, store, evals, local_point)? } - Stage6RelationKind::Stage6HammingBooleanity => { - expected_hamming_booleanity(store, evals, local_point)? - } - Stage6RelationKind::Stage6RamRaVirtual => { - expected_ram_ra_virtual(store, evals, local_point)? - } - Stage6RelationKind::Stage6InstructionRaVirtual => { - expected_instruction_ra_virtual(program, store, evals, local_point)? - } - Stage6RelationKind::Stage6IncClaimReduction => { - expected_inc_claim_reduction(store, evals, local_point)? - } + Stage6RelationKind::Stage6HammingBooleanity + | Stage6RelationKind::Stage6RamRaVirtual + | Stage6RelationKind::Stage6InstructionRaVirtual + | Stage6RelationKind::Stage6IncClaimReduction => expected_plan_output_claim( + program, + instance, + store, + evals, + local_point, + )?, relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; @@ -2412,6 +2616,30 @@ fn expected_batched_output_claim( Ok(expected) } +fn expected_plan_output_claim( + program: &'static Stage6VerifierProgramPlan, + instance: &'static Stage6SumcheckInstanceResultPlan, + store: &bolt_verifier_runtime::ValueStore, + evals: &[Stage6NamedEval], + local_point: &[Fr], +) -> Result { + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage6Error::UnsupportedRelation { + relation: instance.relation, + })?; + Ok(bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )?) +} + fn expected_bytecode_read_raf( program: &'static Stage6VerifierProgramPlan, data: &Stage6BytecodeReadRafData, @@ -2442,39 +2670,6 @@ fn expected_booleanity( Ok(expected_stage67_booleanity(store, evals, local_point, log_t, &STAGE6_RELATION_SYMBOLS)?) } -fn expected_hamming_booleanity( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - Ok(expected_stage67_hamming_booleanity(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?) -} - -fn expected_ram_ra_virtual( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - Ok(expected_stage67_ram_ra_virtual(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?) -} - -fn expected_instruction_ra_virtual( - program: &'static Stage6VerifierProgramPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - Ok(expected_stage67_instruction_ra_virtual(program.opening_inputs, store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?) -} - -fn expected_inc_claim_reduction( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - Ok(expected_stage67_inc_claim_reduction(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?) -} - fn stage6_trace_rounds( program: &'static Stage6VerifierProgramPlan, ) -> Result { @@ -2510,6 +2705,182 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } +fn resolve_stage6_output_claims( + output_values: &[Stage6StructuredPolynomialEvalPlan], + claim_asts: Vec, +) -> Result, EmitError> { + let output_values_by_symbol: BTreeMap<_, _> = output_values + .iter() + .map(|value| (value.symbol.as_str(), value)) + .collect(); + claim_asts + .into_iter() + .map(|claim| { + verify_count( + "sumcheck output claim polynomial_evals", + &claim.relation, + claim.polynomial_evals.len(), + claim.polynomial_eval_operands.len(), + )?; + if claim.polynomial_evals != claim.polynomial_eval_operands { + return Err(EmitError::new(format!( + "stage6 output claim for @{} polynomial_evals do not match operands", + claim.relation + ))); + } + let polynomial_evals = claim + .polynomial_evals + .iter() + .map(|symbol| { + output_values_by_symbol + .get(symbol.as_str()) + .copied() + .cloned() + .ok_or_else(|| { + EmitError::new(format!( + "stage6 output claim for @{} references missing output value @{symbol}", + claim.relation + )) + }) + }) + .collect::, EmitError>>()?; + Ok(Stage6SumcheckOutputClaimPlan { + relation: claim.relation, + polynomial_evals, + claim_value: claim.claim_value, + }) + }) + .collect() +} + +fn prune_prover_output_field_exprs( + field_exprs: &mut Vec, + claims: &[Stage6SumcheckClaimPlan], + output_claims: &[Stage6SumcheckOutputClaimAst], +) { + let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs + .iter() + .map(|expr| (expr.symbol.as_str(), expr)) + .collect(); + let sumcheck_claim_closure = field_expr_dependency_closure( + &field_exprs_by_symbol, + claims.iter().map(|claim| claim.claim_value.as_str()), + ); + let output_claim_closure = field_expr_dependency_closure( + &field_exprs_by_symbol, + output_claims.iter().map(|claim| claim.claim_value.as_str()), + ); + field_exprs.retain(|expr| { + !output_claim_closure.contains(&expr.symbol) + || sumcheck_claim_closure.contains(&expr.symbol) + }); +} + +fn field_expr_dependency_closure<'a>( + field_exprs_by_symbol: &BTreeMap<&str, &Stage6FieldExprPlan>, + roots: impl Iterator, +) -> BTreeSet { + let mut visited = BTreeSet::new(); + let mut stack = roots.map(str::to_owned).collect::>(); + while let Some(symbol) = stack.pop() { + if !visited.insert(symbol.clone()) { + continue; + } + let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { + continue; + }; + for operand in &expr.operands { + if field_exprs_by_symbol.contains_key(operand.as_str()) { + stack.push(operand.clone()); + } + } + } + visited +} + +fn verify_structured_polynomial_point_plan( + stage: &str, + polynomial_eval: &Stage6StructuredPolynomialEvalPlan, + point: &Stage6StructuredPolynomialPointPlan, +) -> Result<(), EmitError> { + if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point segment `{}`", + polynomial_eval.symbol, point.segment + ))); + } + if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point length `{}`", + polynomial_eval.symbol, point.length + ))); + } + if !matches!(point.order.as_str(), "as_is" | "reverse") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point order `{}`", + polynomial_eval.symbol, point.order + ))); + } + Ok(()) +} + +fn stage6_structured_polynomial_kind_expr(polynomial: &str) -> Result<&'static str, EmitError> { + match polynomial { + "eq" => Ok("Stage6StructuredPolynomialKind::Eq"), + "eq_plus_one" => Ok("Stage6StructuredPolynomialKind::EqPlusOne"), + "lt" => Ok("Stage6StructuredPolynomialKind::Lt"), + _ => Err(EmitError::new(format!( + "unsupported stage6 structured polynomial `{polynomial}`" + ))), + } +} + +fn stage6_structured_polynomial_point_expr( + point: &Stage6StructuredPolynomialPointPlan, +) -> Result { + Ok(format!( + "Stage6StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", + rust_str(&point.source), + stage6_structured_polynomial_point_segment_expr(&point.segment)?, + stage6_structured_polynomial_point_length_expr(&point.length)?, + stage6_structured_polynomial_point_order_expr(&point.order)?, + )) +} + +fn stage6_structured_polynomial_point_segment_expr( + segment: &str, +) -> Result<&'static str, EmitError> { + match segment { + "full" => Ok("Stage6StructuredPolynomialPointSegment::Full"), + "prefix" => Ok("Stage6StructuredPolynomialPointSegment::Prefix"), + "suffix" => Ok("Stage6StructuredPolynomialPointSegment::Suffix"), + _ => Err(EmitError::new(format!( + "unsupported stage6 output point segment `{segment}`" + ))), + } +} + +fn stage6_structured_polynomial_point_length_expr(length: &str) -> Result<&'static str, EmitError> { + match length { + "full" => Ok("Stage6StructuredPolynomialPointLength::Full"), + "x_point" => Ok("Stage6StructuredPolynomialPointLength::XPoint"), + "y_point" => Ok("Stage6StructuredPolynomialPointLength::YPoint"), + _ => Err(EmitError::new(format!( + "unsupported stage6 structured polynomial point length `{length}`" + ))), + } +} + +fn stage6_structured_polynomial_point_order_expr(order: &str) -> Result<&'static str, EmitError> { + match order { + "as_is" => Ok("Stage6StructuredPolynomialPointOrder::AsIs"), + "reverse" => Ok("Stage6StructuredPolynomialPointOrder::Reverse"), + _ => Err(EmitError::new(format!( + "unsupported stage6 output point order `{order}`" + ))), + } +} + fn emit_str_array(name: &str, values: &[String]) -> String { if values.is_empty() { return format!("pub const {name}: &[&str] = &[];\n\n"); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index d8030e1238..d97c7c2e28 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1271,6 +1271,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); + let output_claims_field = if self.role == Role::Verifier { + " output_claims: &[],\n" + } else { + "" + }; push_format( &mut source, format_args!( @@ -1289,6 +1294,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); \x20 drivers: STAGE7_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE7_SUMCHECK_EVALS,\n\ + {output_claims_field}\ \x20 point_zeros: STAGE7_POINT_ZEROS,\n\ \x20 point_slices: STAGE7_POINT_SLICES,\n\ \x20 point_concats: STAGE7_POINT_CONCATS,\n\ diff --git a/crates/bolt/src/protocols/jolt/phases/stage5.rs b/crates/bolt/src/protocols/jolt/phases/stage5.rs index 3a7b1171e8..a4807f0564 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage5.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage5.rs @@ -8,6 +8,10 @@ use crate::schema::{verify_protocol_schema, SchemaError}; use super::super::oracles; use super::super::params::JoltProtocolParams; use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type}; +use super::sumcheck_output::{ + append_structured_polynomial_eval, append_sumcheck_output_claim, OutputClaimSpec, + StructuredPolynomialPointSpec, StructuredPolynomialSpec, +}; const RAM_RA_CLAIM_REDUCTION_DEGREE: usize = 2; const REGISTERS_VAL_EVALUATION_DEGREE: usize = 3; @@ -694,7 +698,25 @@ fn append_stage5_batched_sumcheck<'c, 'a>( point, result_value, )?; - append_stage5_output_openings(context, module, params, inputs, instruction, ram, registers)?; + let output_evals = append_stage5_output_openings( + context, + module, + params, + inputs, + instruction, + ram, + registers, + )?; + append_stage5_output_claims( + context, + module, + inputs, + ram, + registers, + &output_evals, + spec.ram_gamma, + ram_gamma2, + )?; Ok(state) } @@ -706,7 +728,7 @@ fn append_stage5_output_openings<'c, 'a>( instruction: (Value<'c, 'a>, Value<'c, 'a>), ram: (Value<'c, 'a>, Value<'c, 'a>), registers: (Value<'c, 'a>, Value<'c, 'a>), -) -> Result<(), MlirError> { +) -> Result, MlirError> { let mut claims = Vec::new(); let mut claim_symbols = Vec::new(); @@ -940,7 +962,157 @@ fn append_stage5_output_openings<'c, 'a>( &claims, &["!piop.opening_batch_type"], )?; - Ok(()) + Ok(Stage5OutputEvals { + ram_ra: ram_ra_eval, + rd_inc: rd_inc_eval, + rd_wa: rd_wa_eval, + }) +} + +#[expect(clippy::too_many_arguments)] +fn append_stage5_output_claims<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + inputs: &Stage5OpeningInputs<'c, 'a>, + ram: (Value<'c, 'a>, Value<'c, 'a>), + registers: (Value<'c, 'a>, Value<'c, 'a>), + output_evals: &Stage5OutputEvals<'c, 'a>, + ram_gamma: Value<'c, 'a>, + ram_gamma2: Value<'c, 'a>, +) -> Result<(), MlirError> { + let ram_raf_eq = append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"), + }, + ram.0, + inputs.ram_ra_raf.point, + )?; + let ram_rw_eq = append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"), + }, + ram.0, + inputs.ram_ra_rw.point, + )?; + let ram_val_eq = append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"), + }, + ram.0, + inputs.ram_ra_val.point, + )?; + let ram_rw_term = append_field_mul( + context, + module, + "stage5.ram_ra_claim_reduction.output.term.ReadWrite", + ram_gamma, + ram_rw_eq, + )?; + let ram_val_term = append_field_mul( + context, + module, + "stage5.ram_ra_claim_reduction.output.term.ValCheck", + ram_gamma2, + ram_val_eq, + )?; + let ram_raf_rw_sum = append_field_add( + context, + module, + "stage5.ram_ra_claim_reduction.output.partial.RafReadWrite", + ram_raf_eq, + ram_rw_term, + )?; + let ram_eq_combined = append_field_add( + context, + module, + "stage5.ram_ra_claim_reduction.output.eq_combined", + ram_raf_rw_sum, + ram_val_term, + )?; + let ram_output_claim = append_field_mul( + context, + module, + "stage5.ram_ra_claim_reduction.output.claim_expr", + ram_eq_combined, + output_evals.ram_ra, + )?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage5.ram_ra_claim_reduction.output.claim", + stage: "stage5", + relation: "jolt.stage5.ram_ra_claim_reduction", + }, + ram_output_claim, + &[ + ("stage5.ram_ra_claim_reduction.output.eq.Raf", ram_raf_eq), + ( + "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", + ram_rw_eq, + ), + ( + "stage5.ram_ra_claim_reduction.output.eq.ValCheck", + ram_val_eq, + ), + ], + )?; + + let registers_lt = append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", + polynomial: "lt", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"), + }, + registers.0, + inputs.registers_val.point, + )?; + let registers_eval_product = append_field_mul( + context, + module, + "stage5.registers_val_evaluation.output.product.RdIncRdWa", + output_evals.rd_inc, + output_evals.rd_wa, + )?; + let registers_output_claim = append_field_mul( + context, + module, + "stage5.registers_val_evaluation.output.claim_expr", + registers_eval_product, + registers_lt, + )?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage5.registers_val_evaluation.output.claim", + stage: "stage5", + relation: "jolt.stage5.registers_val_evaluation", + }, + registers_output_claim, + &[( + "stage5.registers_val_evaluation.output.lt.RegistersValCycle", + registers_lt, + )], + ) } fn append_opening_claim_equal<'c>( @@ -1305,6 +1477,12 @@ struct Stage5OpeningInputs<'c, 'a> { registers_val: Stage5OpeningInput<'c, 'a>, } +struct Stage5OutputEvals<'c, 'a> { + ram_ra: Value<'c, 'a>, + rd_inc: Value<'c, 'a>, + rd_wa: Value<'c, 'a>, +} + struct StageOpeningInputSpec<'a> { symbol: &'a str, source_stage: &'a str, diff --git a/crates/bolt/src/protocols/jolt/phases/stage6.rs b/crates/bolt/src/protocols/jolt/phases/stage6.rs index 2e474f42c5..a8389a3d00 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage6.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage6.rs @@ -10,6 +10,10 @@ use crate::schema::{verify_protocol_schema, SchemaError}; use super::super::oracles; use super::super::params::JoltProtocolParams; use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type}; +use super::sumcheck_output::{ + append_structured_polynomial_eval, append_sumcheck_output_claim, OutputClaimSpec, + StructuredPolynomialPointSpec, StructuredPolynomialSpec, +}; const BOOLEANITY_DEGREE: usize = 3; const HAMMING_BOOLEANITY_DEGREE: usize = 3; @@ -1188,7 +1192,7 @@ fn append_stage6_batched_sumcheck<'c, 'a>( degree: INC_CLAIM_REDUCTION_DEGREE, }, )?; - append_stage6_output_openings( + let output_evals = append_stage6_output_openings( context, module, params, @@ -1200,6 +1204,19 @@ fn append_stage6_batched_sumcheck<'c, 'a>( instruction, inc, )?; + append_stage6_output_claims( + context, + module, + params, + inputs, + hamming, + ram, + instruction, + inc, + &output_evals, + spec.inst_ra_gamma, + spec.inc_gamma, + )?; Ok(state) } @@ -1421,9 +1438,13 @@ fn append_stage6_output_openings<'c, 'a>( ram: (Value<'c, 'a>, Value<'c, 'a>), instruction: (Value<'c, 'a>, Value<'c, 'a>), inc: (Value<'c, 'a>, Value<'c, 'a>), -) -> Result<(), MlirError> { +) -> Result, MlirError> { let mut claims = Vec::new(); let mut claim_symbols = Vec::new(); + let mut ram_ra = Vec::with_capacity(params.ram_d); + let mut instruction_ra = Vec::with_capacity(params.instruction_d); + let mut ram_inc = None; + let mut rd_inc = None; let bytecode_cycle = append_point_slice( context, @@ -1576,6 +1597,7 @@ fn append_stage6_output_openings<'c, 'a>( index, ram.1, )?; + ram_ra.push(eval); claim_symbols.push(symbol.clone()); claims.push(append_opening_claim( context, @@ -1624,6 +1646,7 @@ fn append_stage6_output_openings<'c, 'a>( index, instruction.1, )?; + instruction_ra.push(eval); claim_symbols.push(symbol.clone()); claims.push(append_opening_claim( context, @@ -1651,6 +1674,11 @@ fn append_stage6_output_openings<'c, 'a>( index, inc.1, )?; + if *oracle == "RamInc" { + ram_inc = Some(eval); + } else { + rd_inc = Some(eval); + } claim_symbols.push(symbol.clone()); claims.push(append_opening_claim( context, @@ -1682,7 +1710,377 @@ fn append_stage6_output_openings<'c, 'a>( &claims, &["!piop.opening_batch_type"], )?; - Ok(()) + Ok(Stage6OutputEvals { + hamming_weight: hamming_eval, + ram_ra, + instruction_ra, + ram_inc: ram_inc.ok_or_else(|| schema_error("missing stage6 RamInc output eval"))?, + rd_inc: rd_inc.ok_or_else(|| schema_error("missing stage6 RdInc output eval"))?, + }) +} + +#[expect(clippy::too_many_arguments)] +fn append_stage6_output_claims<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + params: &JoltProtocolParams, + inputs: &Stage6OpeningInputs<'c, 'a>, + hamming: (Value<'c, 'a>, Value<'c, 'a>), + ram: (Value<'c, 'a>, Value<'c, 'a>), + instruction: (Value<'c, 'a>, Value<'c, 'a>), + inc: (Value<'c, 'a>, Value<'c, 'a>), + output_evals: &Stage6OutputEvals<'c, 'a>, + instruction_gamma: Value<'c, 'a>, + inc_gamma: Value<'c, 'a>, +) -> Result<(), MlirError> { + append_stage6_hamming_output_claim(context, module, inputs, hamming, output_evals)?; + append_stage6_ram_ra_virtual_output_claim(context, module, inputs, ram, output_evals)?; + append_stage6_instruction_ra_virtual_output_claim( + context, + module, + params, + inputs, + instruction, + output_evals, + instruction_gamma, + )?; + append_stage6_inc_output_claim(context, module, inputs, inc, output_evals, inc_gamma) +} + +fn append_stage6_hamming_output_claim<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + inputs: &Stage6OpeningInputs<'c, 'a>, + hamming: (Value<'c, 'a>, Value<'c, 'a>), + output_evals: &Stage6OutputEvals<'c, 'a>, +) -> Result<(), MlirError> { + let eq_lookup = append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("as_is"), + y_point: StructuredPolynomialPointSpec::full("reverse"), + }, + hamming.0, + inputs.hamming_lookup_output.point, + )?; + let hamming_square = append_field_pow( + context, + module, + "stage6.hamming_booleanity.output.square.HammingWeight", + output_evals.hamming_weight, + 2, + )?; + let neg_hamming = append_field_neg( + context, + module, + "stage6.hamming_booleanity.output.neg.HammingWeight", + output_evals.hamming_weight, + )?; + let hamming_boolean = append_field_add( + context, + module, + "stage6.hamming_booleanity.output.boolean", + hamming_square, + neg_hamming, + )?; + let claim = append_field_mul( + context, + module, + "stage6.hamming_booleanity.output.claim_expr", + hamming_boolean, + eq_lookup, + )?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage6.hamming_booleanity.output.claim", + stage: "stage6", + relation: "jolt.stage6.hamming_booleanity", + }, + claim, + &[( + "stage6.hamming_booleanity.output.eq.LookupOutput", + eq_lookup, + )], + ) +} + +fn append_stage6_ram_ra_virtual_output_claim<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + inputs: &Stage6OpeningInputs<'c, 'a>, + ram: (Value<'c, 'a>, Value<'c, 'a>), + output_evals: &Stage6OutputEvals<'c, 'a>, +) -> Result<(), MlirError> { + let eq_cycle = append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol: "stage6.ram_ra_virtual.output.eq.Cycle", + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"), + }, + ram.0, + inputs.ram_ra_virtual.point, + )?; + let ram_product = append_field_product( + context, + module, + "stage6.ram_ra_virtual.output.product.RamRa", + &output_evals.ram_ra, + )?; + let claim = append_field_mul( + context, + module, + "stage6.ram_ra_virtual.output.claim_expr", + eq_cycle, + ram_product, + )?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage6.ram_ra_virtual.output.claim", + stage: "stage6", + relation: "jolt.stage6.ram_ra_virtual", + }, + claim, + &[("stage6.ram_ra_virtual.output.eq.Cycle", eq_cycle)], + ) +} + +fn append_stage6_instruction_ra_virtual_output_claim<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + params: &JoltProtocolParams, + inputs: &Stage6OpeningInputs<'c, 'a>, + instruction: (Value<'c, 'a>, Value<'c, 'a>), + output_evals: &Stage6OutputEvals<'c, 'a>, + gamma: Value<'c, 'a>, +) -> Result<(), MlirError> { + let eq_cycle = append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"), + }, + instruction.0, + inputs.instruction_ra_virtual[0].point, + )?; + let committed_per_virtual = n_committed_per_virtual(params); + let mut virtual_terms = Vec::with_capacity(inputs.instruction_ra_virtual.len()); + for (index, chunk) in output_evals + .instruction_ra + .chunks(committed_per_virtual) + .enumerate() + { + let product = append_field_product( + context, + module, + &format!("stage6.instruction_ra_virtual.output.product.InstructionRa_{index}"), + chunk, + )?; + if index == 0 { + virtual_terms.push(product); + } else { + let gamma_power = append_field_pow( + context, + module, + &format!("stage6.instruction_ra_virtual.output.gamma_pow_{index}"), + gamma, + index, + )?; + virtual_terms.push(append_field_mul( + context, + module, + &format!("stage6.instruction_ra_virtual.output.term.InstructionRa_{index}"), + gamma_power, + product, + )?); + } + } + let weighted_sum = append_field_sum( + context, + module, + "stage6.instruction_ra_virtual.output.weighted_sum", + &virtual_terms, + )?; + let claim = append_field_mul( + context, + module, + "stage6.instruction_ra_virtual.output.claim_expr", + eq_cycle, + weighted_sum, + )?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage6.instruction_ra_virtual.output.claim", + stage: "stage6", + relation: "jolt.stage6.instruction_ra_virtual", + }, + claim, + &[("stage6.instruction_ra_virtual.output.eq.Cycle", eq_cycle)], + ) +} + +fn append_stage6_inc_output_claim<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + inputs: &Stage6OpeningInputs<'c, 'a>, + inc: (Value<'c, 'a>, Value<'c, 'a>), + output_evals: &Stage6OutputEvals<'c, 'a>, + gamma: Value<'c, 'a>, +) -> Result<(), MlirError> { + let eq_ram_stage2 = append_stage6_inc_eq( + context, + module, + "stage6.inc_claim_reduction.output.eq.RamIncStage2", + inc.0, + inputs.ram_inc_stage2.point, + )?; + let eq_ram_stage4 = append_stage6_inc_eq( + context, + module, + "stage6.inc_claim_reduction.output.eq.RamIncStage4", + inc.0, + inputs.ram_inc_stage4.point, + )?; + let eq_rd_stage4 = append_stage6_inc_eq( + context, + module, + "stage6.inc_claim_reduction.output.eq.RdIncStage4", + inc.0, + inputs.rd_inc_stage4.point, + )?; + let eq_rd_stage5 = append_stage6_inc_eq( + context, + module, + "stage6.inc_claim_reduction.output.eq.RdIncStage5", + inc.0, + inputs.rd_inc_stage5.point, + )?; + let ram_stage4_term = append_field_mul( + context, + module, + "stage6.inc_claim_reduction.output.term.RamIncStage4", + gamma, + eq_ram_stage4, + )?; + let ram_eq_combined = append_field_add( + context, + module, + "stage6.inc_claim_reduction.output.eq.RamCombined", + eq_ram_stage2, + ram_stage4_term, + )?; + let ram_term = append_field_mul( + context, + module, + "stage6.inc_claim_reduction.output.term.RamInc", + output_evals.ram_inc, + ram_eq_combined, + )?; + let rd_stage5_term = append_field_mul( + context, + module, + "stage6.inc_claim_reduction.output.term.RdIncStage5", + gamma, + eq_rd_stage5, + )?; + let rd_eq_combined = append_field_add( + context, + module, + "stage6.inc_claim_reduction.output.eq.RdCombined", + eq_rd_stage4, + rd_stage5_term, + )?; + let rd_eval_term = append_field_mul( + context, + module, + "stage6.inc_claim_reduction.output.term.RdInc", + output_evals.rd_inc, + rd_eq_combined, + )?; + let gamma2 = append_field_pow( + context, + module, + "stage6.inc_claim_reduction.output.gamma2", + gamma, + 2, + )?; + let rd_term = append_field_mul( + context, + module, + "stage6.inc_claim_reduction.output.term.RdWeighted", + gamma2, + rd_eval_term, + )?; + let claim = append_field_add( + context, + module, + "stage6.inc_claim_reduction.output.claim_expr", + ram_term, + rd_term, + )?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage6.inc_claim_reduction.output.claim", + stage: "stage6", + relation: "jolt.stage6.inc_claim_reduction", + }, + claim, + &[ + ( + "stage6.inc_claim_reduction.output.eq.RamIncStage2", + eq_ram_stage2, + ), + ( + "stage6.inc_claim_reduction.output.eq.RamIncStage4", + eq_ram_stage4, + ), + ( + "stage6.inc_claim_reduction.output.eq.RdIncStage4", + eq_rd_stage4, + ), + ( + "stage6.inc_claim_reduction.output.eq.RdIncStage5", + eq_rd_stage5, + ), + ], + ) +} + +fn append_stage6_inc_eq<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + symbol: &str, + instance_point: Value<'c, 'a>, + input_point: Value<'c, 'a>, +) -> Result, MlirError> { + append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol, + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::suffix("x_point", "as_is"), + }, + instance_point, + input_point, + ) } #[expect(clippy::too_many_arguments)] @@ -1778,6 +2176,23 @@ fn append_field_mul<'c, 'a>( append_field_binary(context, module, "field.mul", symbol, lhs, rhs) } +fn append_field_neg<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + symbol: &str, + value: Value<'c, 'a>, +) -> Result, MlirError> { + let op = context.append_typed_op( + module, + "field.neg", + Some(symbol), + &[], + &[value], + &["!field.scalar"], + )?; + first_result(op, "field.neg") +} + fn append_field_pow<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, @@ -1818,6 +2233,30 @@ fn append_field_sum<'c, 'a>( Ok(value) } +fn append_field_product<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + symbol_prefix: &str, + factors: &[Value<'c, 'a>], +) -> Result, MlirError> { + let Some((&first, rest)) = factors.split_first() else { + return Err(schema_error(format!( + "{symbol_prefix} requires at least one factor" + ))); + }; + let mut value = first; + for (index, &factor) in rest.iter().enumerate() { + value = append_field_mul( + context, + module, + &format!("{symbol_prefix}.partial{index}"), + value, + factor, + )?; + } + Ok(value) +} + fn append_sumcheck_claim<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, @@ -2227,6 +2666,14 @@ struct Stage6OpeningInputs<'c, 'a> { rd_inc_stage5: Stage6OpeningInput<'c, 'a>, } +struct Stage6OutputEvals<'c, 'a> { + hamming_weight: Value<'c, 'a>, + ram_ra: Vec>, + instruction_ra: Vec>, + ram_inc: Value<'c, 'a>, + rd_inc: Value<'c, 'a>, +} + struct Stage6OpeningInput<'c, 'a> { point: Value<'c, 'a>, eval: Value<'c, 'a>, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index b4285ecf8a..2263dfaeb8 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -816,6 +816,12 @@ fn jolt_stage5_protocol_defines_value_lookup_reduction_flow() { assert!(text.contains("@stage5.ram_ra_claim_reduction.opening.RamRa")); assert!(text.contains("@stage5.registers_val_evaluation.opening.RdInc")); assert!(text.contains("@stage5.registers_val_evaluation.opening.RdWa")); + assert!(text.contains("sym_name = \"stage5.ram_ra_claim_reduction.output.eq.Raf\"")); + assert!(text.contains("sym_name = \"stage5.ram_ra_claim_reduction.output.claim\"")); + assert!( + text.contains("sym_name = \"stage5.registers_val_evaluation.output.lt.RegistersValCycle\"") + ); + assert!(text.contains("sym_name = \"stage5.registers_val_evaluation.output.claim\"")); assert!(!text.contains("kernel = @")); assert!(!text.contains("\"compute.")); } @@ -868,6 +874,8 @@ fn jolt_stage5_lowers_to_compute_and_cpu_role_ir() { assert!(prover_kernel_text.contains("kernel = @jolt.cpu.stage5.batched")); assert!(prover_cpu_text.contains("kernel = @jolt.cpu.stage5.batched")); assert!(prover_cpu_text.contains("point_order = \"instruction_read_raf\"")); + assert!(verifier_cpu_text.contains("\"cpu.structured_polynomial_eval\"")); + assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_claim\"")); assert!(verifier_cpu_text.contains("\"cpu.sumcheck_verify_claim\"")); assert!(!verifier_kernel_text.contains("kernel = @")); assert!(!verifier_cpu_text.contains("kernel = @")); @@ -908,6 +916,11 @@ fn jolt_stage6_protocol_defines_bytecode_booleanity_and_virtualization_flow() { assert!(text.contains("@stage6.instruction_ra_virtual.opening.InstructionRa_0")); assert!(text.contains("@stage6.inc_claim_reduction.opening.RamInc")); assert!(text.contains("@stage6.inc_claim_reduction.opening.RdInc")); + assert!(text.contains("sym_name = \"stage6.hamming_booleanity.output.claim\"")); + assert!(text.contains("sym_name = \"stage6.ram_ra_virtual.output.claim\"")); + assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.output.claim\"")); + assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.claim\"")); + assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.eq.RdIncStage5\"")); assert!(!text.contains("kernel = @")); assert!(!text.contains("\"compute.")); } @@ -961,6 +974,8 @@ fn jolt_stage6_lowers_to_compute_and_cpu_role_ir() { assert!(prover_cpu_text.contains("kernel = @jolt.cpu.stage6.batched")); assert!(prover_cpu_text.contains("point_order = \"bytecode_read_raf\"")); assert!(verifier_cpu_text.contains("\"cpu.sumcheck_verify_claim\"")); + assert!(verifier_cpu_text.contains("\"cpu.structured_polynomial_eval\"")); + assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_claim\"")); assert!(!verifier_kernel_text.contains("kernel = @")); assert!(!verifier_cpu_text.contains("kernel = @")); } @@ -1349,6 +1364,10 @@ fn stage5_rust_targets_extract_and_compile() { prover_program.evals.len(), params.lookup_table_count + params.instruction_ra_virtual_d + 4 ); + assert_eq!(prover_program.output_values.len(), 4); + assert!(prover_program.output_claims.is_empty()); + assert_eq!(verifier_program.output_values.len(), 4); + assert_eq!(verifier_program.output_claims.len(), 2); assert_eq!( prover_program.point_slices.len(), params.instruction_ra_virtual_d + 3 @@ -1407,12 +1426,24 @@ fn stage5_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("use jolt_lookup_tables::LookupTableKind")); - assert!(verifier_source + assert!(!verifier_source .source .contains("expected_ram_ra_claim_reduction")); - assert!(verifier_source + assert!(!verifier_source .source .contains("expected_registers_val_evaluation")); + assert!(verifier_source + .source + .contains("Stage5SumcheckOutputClaimPlan")); + assert!(verifier_source + .source + .contains("stage5.ram_ra_claim_reduction.output.eq.ReadWrite")); + assert!(verifier_source + .source + .contains("stage5.registers_val_evaluation.output.lt.RegistersValCycle")); + assert!(verifier_source + .source + .contains("bolt_verifier_runtime::evaluate_sumcheck_output_claim")); assert!(verifier_source .source .contains("Stage5RelationKind::Stage5RamRaClaimReduction")); @@ -1473,6 +1504,10 @@ fn stage6_rust_targets_extract_and_compile() { + params.instruction_d + 2 ); + assert_eq!(prover_program.output_values.len(), 7); + assert!(prover_program.output_claims.is_empty()); + assert_eq!(verifier_program.output_values.len(), 7); + assert_eq!(verifier_program.output_claims.len(), 4); assert_eq!(prover_program.point_zeros.len(), 1); assert_eq!( prover_program.point_slices.len(), @@ -1551,22 +1586,34 @@ fn stage6_rust_targets_extract_and_compile() { .source .contains("stage6.bytecode_read_raf.data")); assert!(verifier_source.source.contains("expected_booleanity")); - assert!(verifier_source + assert!(!verifier_source .source .contains("expected_hamming_booleanity")); + assert!(verifier_source + .source + .contains("expected_plan_output_claim")); + assert!(verifier_source + .source + .contains("stage6.hamming_booleanity.output.eq.LookupOutput")); assert!(verifier_source .source .contains("Stage6RelationKind::Stage6IncClaimReduction")); assert!(verifier_source .source .contains("stage6.input.stage1.LookupOutput")); - assert!(verifier_source.source.contains("expected_ram_ra_virtual")); - assert!(verifier_source + assert!(!verifier_source.source.contains("expected_ram_ra_virtual")); + assert!(!verifier_source .source .contains("expected_instruction_ra_virtual")); - assert!(verifier_source + assert!(!verifier_source .source .contains("expected_inc_claim_reduction")); + assert!(verifier_source + .source + .contains("Stage6SumcheckOutputClaimPlan")); + assert!(verifier_source + .source + .contains("stage6.inc_claim_reduction.output.eq.RdIncStage5")); assert!(verifier_source .source .contains("stage6.bytecode_read_raf.eval.BytecodeRa_0")); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs index ba4ce74004..cbed81baca 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs @@ -25,5 +25,6 @@ define_stage_adapter!( Stage5OpeningClaimPlan, Stage5OpeningClaimEqualityPlan, Stage5OpeningBatchPlan, - empty_output_claims = yes + output_claims = Stage5SumcheckOutputClaimPlan, + output_values = Stage5StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs index 76072dd614..471e9481af 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs @@ -25,5 +25,7 @@ define_stage_adapter!( Stage6OpeningClaimPlan, Stage6OpeningClaimEqualityPlan, Stage6OpeningBatchPlan, - point_zero = Stage6PointZeroPlan + point_zero = Stage6PointZeroPlan, + output_claims = Stage6SumcheckOutputClaimPlan, + output_values = Stage6StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs index 457ac30812..cac54f9ba5 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs @@ -25,5 +25,6 @@ define_stage_adapter!( Stage7OpeningClaimPlan, Stage7OpeningClaimEqualityPlan, Stage7OpeningBatchPlan, - point_zero = Stage7PointZeroPlan + point_zero = Stage7PointZeroPlan, + empty_output_claims = yes ); diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 608a8cdf69..e3e83e28c9 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,8 +1,8 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice, suffix_point}; -use super::jolt_relations::{identity_polynomial_eval, lt_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval}; -use jolt_field::{Field, Fr, RingCore}; +use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice}; +use super::jolt_relations::{identity_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval}; +use jolt_field::{Field, Fr}; use jolt_lookup_tables::LookupTableKind; use jolt_poly::EqPolynomial; use jolt_sumcheck::SumcheckError; @@ -18,6 +18,8 @@ pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZe pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage5SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage5SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage5StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage5RelationKind; pub use bolt_verifier_runtime::{ @@ -33,6 +35,11 @@ pub use bolt_verifier_runtime::{ ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params, SumcheckBatchPlan as Stage5SumcheckBatchPlan, SumcheckEvalPlan as Stage5SumcheckEvalPlan, + StructuredPolynomialPointLength as Stage5StructuredPolynomialPointLength, + StructuredPolynomialPointOrder as Stage5StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment as Stage5StructuredPolynomialPointSegment, + StructuredPolynomialKind as Stage5StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage5TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage5TranscriptSqueezeKind, TranscriptSqueezePlan as Stage5TranscriptSqueezePlan, @@ -98,6 +105,13 @@ pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[ Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.term.RamRaValCheck", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.gamma2", "stage5.input.stage4.ram_val_check.RamRa"] }, Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.partial.RafReadWrite", kind: Stage5FieldExprKind::Add, operands: &["stage5.input.stage2.ram_raf.RamRa", "stage5.ram_ra_claim_reduction.term.RamRaReadWrite"] }, Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.claim_expr", kind: Stage5FieldExprKind::Add, operands: &["stage5.ram_ra_claim_reduction.partial.RafReadWrite", "stage5.ram_ra_claim_reduction.term.RamRaValCheck"] }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.term.ReadWrite", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.gamma", "stage5.ram_ra_claim_reduction.output.eq.ReadWrite"] }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.term.ValCheck", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.gamma2", "stage5.ram_ra_claim_reduction.output.eq.ValCheck"] }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.partial.RafReadWrite", kind: Stage5FieldExprKind::Add, operands: &["stage5.ram_ra_claim_reduction.output.eq.Raf", "stage5.ram_ra_claim_reduction.output.term.ReadWrite"] }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq_combined", kind: Stage5FieldExprKind::Add, operands: &["stage5.ram_ra_claim_reduction.output.partial.RafReadWrite", "stage5.ram_ra_claim_reduction.output.term.ValCheck"] }, + Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.output.eq_combined", "stage5.ram_ra_claim_reduction.eval.RamRa"] }, + Stage5FieldExprPlan { symbol: "stage5.registers_val_evaluation.output.product.RdIncRdWa", kind: Stage5FieldExprKind::Mul, operands: &["stage5.registers_val_evaluation.eval.RdInc", "stage5.registers_val_evaluation.eval.RdWa"] }, + Stage5FieldExprPlan { symbol: "stage5.registers_val_evaluation.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.registers_val_evaluation.output.product.RdIncRdWa", "stage5.registers_val_evaluation.output.lt.RegistersValCycle"] }, ]; pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[ @@ -269,6 +283,21 @@ pub const STAGE5_OPENING_EQUALITIES: &[Stage5OpeningClaimEqualityPlan] = &[ pub const STAGE5_OPENING_BATCHES: &[Stage5OpeningBatchPlan] = &[ Stage5OpeningBatchPlan { symbol: "stage5.openings", stage: "stage5", proof_slot: "stage5.openings", policy: "jolt_stage5_output_order", count: 53, ordered_claims: &["stage5.instruction_read_raf.opening.LookupTableFlag_0", "stage5.instruction_read_raf.opening.LookupTableFlag_1", "stage5.instruction_read_raf.opening.LookupTableFlag_2", "stage5.instruction_read_raf.opening.LookupTableFlag_3", "stage5.instruction_read_raf.opening.LookupTableFlag_4", "stage5.instruction_read_raf.opening.LookupTableFlag_5", "stage5.instruction_read_raf.opening.LookupTableFlag_6", "stage5.instruction_read_raf.opening.LookupTableFlag_7", "stage5.instruction_read_raf.opening.LookupTableFlag_8", "stage5.instruction_read_raf.opening.LookupTableFlag_9", "stage5.instruction_read_raf.opening.LookupTableFlag_10", "stage5.instruction_read_raf.opening.LookupTableFlag_11", "stage5.instruction_read_raf.opening.LookupTableFlag_12", "stage5.instruction_read_raf.opening.LookupTableFlag_13", "stage5.instruction_read_raf.opening.LookupTableFlag_14", "stage5.instruction_read_raf.opening.LookupTableFlag_15", "stage5.instruction_read_raf.opening.LookupTableFlag_16", "stage5.instruction_read_raf.opening.LookupTableFlag_17", "stage5.instruction_read_raf.opening.LookupTableFlag_18", "stage5.instruction_read_raf.opening.LookupTableFlag_19", "stage5.instruction_read_raf.opening.LookupTableFlag_20", "stage5.instruction_read_raf.opening.LookupTableFlag_21", "stage5.instruction_read_raf.opening.LookupTableFlag_22", "stage5.instruction_read_raf.opening.LookupTableFlag_23", "stage5.instruction_read_raf.opening.LookupTableFlag_24", "stage5.instruction_read_raf.opening.LookupTableFlag_25", "stage5.instruction_read_raf.opening.LookupTableFlag_26", "stage5.instruction_read_raf.opening.LookupTableFlag_27", "stage5.instruction_read_raf.opening.LookupTableFlag_28", "stage5.instruction_read_raf.opening.LookupTableFlag_29", "stage5.instruction_read_raf.opening.LookupTableFlag_30", "stage5.instruction_read_raf.opening.LookupTableFlag_31", "stage5.instruction_read_raf.opening.LookupTableFlag_32", "stage5.instruction_read_raf.opening.LookupTableFlag_33", "stage5.instruction_read_raf.opening.LookupTableFlag_34", "stage5.instruction_read_raf.opening.LookupTableFlag_35", "stage5.instruction_read_raf.opening.LookupTableFlag_36", "stage5.instruction_read_raf.opening.LookupTableFlag_37", "stage5.instruction_read_raf.opening.LookupTableFlag_38", "stage5.instruction_read_raf.opening.LookupTableFlag_39", "stage5.instruction_read_raf.opening.LookupTableFlag_40", "stage5.instruction_read_raf.opening.InstructionRa_0", "stage5.instruction_read_raf.opening.InstructionRa_1", "stage5.instruction_read_raf.opening.InstructionRa_2", "stage5.instruction_read_raf.opening.InstructionRa_3", "stage5.instruction_read_raf.opening.InstructionRa_4", "stage5.instruction_read_raf.opening.InstructionRa_5", "stage5.instruction_read_raf.opening.InstructionRa_6", "stage5.instruction_read_raf.opening.InstructionRa_7", "stage5.instruction_read_raf.opening.InstructionRafFlag", "stage5.ram_ra_claim_reduction.opening.RamRa", "stage5.registers_val_evaluation.opening.RdInc", "stage5.registers_val_evaluation.opening.RdWa"], claim_operands: &["stage5.instruction_read_raf.opening.LookupTableFlag_0", "stage5.instruction_read_raf.opening.LookupTableFlag_1", "stage5.instruction_read_raf.opening.LookupTableFlag_2", "stage5.instruction_read_raf.opening.LookupTableFlag_3", "stage5.instruction_read_raf.opening.LookupTableFlag_4", "stage5.instruction_read_raf.opening.LookupTableFlag_5", "stage5.instruction_read_raf.opening.LookupTableFlag_6", "stage5.instruction_read_raf.opening.LookupTableFlag_7", "stage5.instruction_read_raf.opening.LookupTableFlag_8", "stage5.instruction_read_raf.opening.LookupTableFlag_9", "stage5.instruction_read_raf.opening.LookupTableFlag_10", "stage5.instruction_read_raf.opening.LookupTableFlag_11", "stage5.instruction_read_raf.opening.LookupTableFlag_12", "stage5.instruction_read_raf.opening.LookupTableFlag_13", "stage5.instruction_read_raf.opening.LookupTableFlag_14", "stage5.instruction_read_raf.opening.LookupTableFlag_15", "stage5.instruction_read_raf.opening.LookupTableFlag_16", "stage5.instruction_read_raf.opening.LookupTableFlag_17", "stage5.instruction_read_raf.opening.LookupTableFlag_18", "stage5.instruction_read_raf.opening.LookupTableFlag_19", "stage5.instruction_read_raf.opening.LookupTableFlag_20", "stage5.instruction_read_raf.opening.LookupTableFlag_21", "stage5.instruction_read_raf.opening.LookupTableFlag_22", "stage5.instruction_read_raf.opening.LookupTableFlag_23", "stage5.instruction_read_raf.opening.LookupTableFlag_24", "stage5.instruction_read_raf.opening.LookupTableFlag_25", "stage5.instruction_read_raf.opening.LookupTableFlag_26", "stage5.instruction_read_raf.opening.LookupTableFlag_27", "stage5.instruction_read_raf.opening.LookupTableFlag_28", "stage5.instruction_read_raf.opening.LookupTableFlag_29", "stage5.instruction_read_raf.opening.LookupTableFlag_30", "stage5.instruction_read_raf.opening.LookupTableFlag_31", "stage5.instruction_read_raf.opening.LookupTableFlag_32", "stage5.instruction_read_raf.opening.LookupTableFlag_33", "stage5.instruction_read_raf.opening.LookupTableFlag_34", "stage5.instruction_read_raf.opening.LookupTableFlag_35", "stage5.instruction_read_raf.opening.LookupTableFlag_36", "stage5.instruction_read_raf.opening.LookupTableFlag_37", "stage5.instruction_read_raf.opening.LookupTableFlag_38", "stage5.instruction_read_raf.opening.LookupTableFlag_39", "stage5.instruction_read_raf.opening.LookupTableFlag_40", "stage5.instruction_read_raf.opening.InstructionRa_0", "stage5.instruction_read_raf.opening.InstructionRa_1", "stage5.instruction_read_raf.opening.InstructionRa_2", "stage5.instruction_read_raf.opening.InstructionRa_3", "stage5.instruction_read_raf.opening.InstructionRa_4", "stage5.instruction_read_raf.opening.InstructionRa_5", "stage5.instruction_read_raf.opening.InstructionRa_6", "stage5.instruction_read_raf.opening.InstructionRa_7", "stage5.instruction_read_raf.opening.InstructionRafFlag", "stage5.ram_ra_claim_reduction.opening.RamRa", "stage5.registers_val_evaluation.opening.RdInc", "stage5.registers_val_evaluation.opening.RdWa"] }, ]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ + Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.ram_raf.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, + Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.ram_read_write.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, + Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage4.ram_val_check.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, +]; + +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ + Stage5StructuredPolynomialEvalPlan { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", polynomial: Stage5StructuredPolynomialKind::Lt, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.registers_val_evaluation.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage4.registers.RegistersVal", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, +]; + +pub const STAGE5_SUMCHECK_OUTPUT_CLAIMS: &[Stage5SumcheckOutputClaimPlan] = &[ + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, +]; + pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { role: "verifier", params: STAGE5_PARAMS, @@ -284,7 +313,7 @@ pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { drivers: STAGE5_SUMCHECK_DRIVERS, instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS, evals: STAGE5_SUMCHECK_EVALS, - output_claims: &[], + output_claims: STAGE5_SUMCHECK_OUTPUT_CLAIMS, point_slices: STAGE5_POINT_SLICES, point_concats: STAGE5_POINT_CONCATS, opening_claims: STAGE5_OPENING_CLAIMS, @@ -548,10 +577,38 @@ fn expected_batched_output_claim( expected_instruction_read_raf(store, evals, local_point)? } Stage5RelationKind::Stage5RamRaClaimReduction => { - expected_ram_ra_claim_reduction(store, evals, local_point)? + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage5Error::UnsupportedRelation { + relation: instance.relation, + })?; + bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )? } Stage5RelationKind::Stage5RegistersValEvaluation => { - expected_registers_val_evaluation(store, evals, local_point)? + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage5Error::UnsupportedRelation { + relation: instance.relation, + })?; + bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )? } relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }), }; @@ -617,50 +674,3 @@ fn expected_instruction_read_raf( + raf_flag_claim * gamma * identity_poly_eval; Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim)) } - -fn expected_ram_ra_claim_reduction( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage5NamedEval], - local_point: &[Fr], -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let r_cycle_raf = suffix_point( - bolt_verifier_runtime::store_point(store, "stage5.input.stage2.ram_raf.RamRa")?, - r_cycle_reduced.len(), - "stage5.input.stage2.ram_raf.RamRa", - )?; - let r_cycle_rw = suffix_point( - bolt_verifier_runtime::store_point(store, "stage5.input.stage2.ram_read_write.RamRa")?, - r_cycle_reduced.len(), - "stage5.input.stage2.ram_read_write.RamRa", - )?; - let r_cycle_val = suffix_point( - bolt_verifier_runtime::store_point(store, "stage5.input.stage4.ram_val_check.RamRa")?, - r_cycle_reduced.len(), - "stage5.input.stage4.ram_val_check.RamRa", - )?; - let gamma = bolt_verifier_runtime::store_scalar(store, "stage5.ram_ra_claim_reduction.gamma")?; - let eq_combined = EqPolynomial::::mle(r_cycle_raf, &r_cycle_reduced) - + gamma * EqPolynomial::::mle(r_cycle_rw, &r_cycle_reduced) - + gamma.square() * EqPolynomial::::mle(r_cycle_val, &r_cycle_reduced); - let ram_ra = eval_by_name(evals, "stage5.ram_ra_claim_reduction.eval.RamRa")?; - Ok(eq_combined * ram_ra) -} - -fn expected_registers_val_evaluation( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage5NamedEval], - local_point: &[Fr], -) -> Result { - let registers_val_point = bolt_verifier_runtime::store_point(store, "stage5.input.stage4.registers.RegistersVal")?; - let r_cycle = suffix_point( - registers_val_point, - local_point.len(), - "stage5.input.stage4.registers.RegistersVal", - )?; - let r_reduced = reverse_slice(local_point); - let lt_eval = lt_polynomial_eval(&r_reduced, r_cycle); - let rd_inc = eval_by_name(evals, "stage5.registers_val_evaluation.eval.RdInc")?; - let rd_wa = eval_by_name(evals, "stage5.registers_val_evaluation.eval.RdWa")?; - Ok(rd_inc * rd_wa * lt_eval) -} diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index ecba02932b..d1245f3953 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; -use super::jolt_relations::{expected_stage67_booleanity, expected_stage67_bytecode_read_raf, expected_stage67_hamming_booleanity, expected_stage67_inc_claim_reduction, expected_stage67_instruction_ra_virtual, expected_stage67_ram_ra_virtual, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols}; +use super::jolt_relations::{expected_stage67_booleanity, expected_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -16,6 +16,8 @@ pub type Stage6CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage6SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage6SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage6SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage6StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage6RelationKind; pub use bolt_verifier_runtime::{ @@ -32,6 +34,11 @@ pub use bolt_verifier_runtime::{ StageParams as Stage6Params, SumcheckBatchPlan as Stage6SumcheckBatchPlan, SumcheckEvalPlan as Stage6SumcheckEvalPlan, + StructuredPolynomialPointLength as Stage6StructuredPolynomialPointLength, + StructuredPolynomialPointOrder as Stage6StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment as Stage6StructuredPolynomialPointSegment, + StructuredPolynomialKind as Stage6StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage6TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage6TranscriptSqueezeKind, TranscriptSqueezePlan as Stage6TranscriptSqueezePlan, @@ -347,6 +354,14 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), + stage6_field_expr("stage6.hamming_booleanity.output.square.HammingWeight", Stage6FieldExprKind::Pow(2), &["stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.neg.HammingWeight", Stage6FieldExprKind::Neg, &["stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean", Stage6FieldExprKind::Add, &["stage6.hamming_booleanity.output.square.HammingWeight", "stage6.hamming_booleanity.output.neg.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.hamming_booleanity.output.boolean", "stage6.hamming_booleanity.output.eq.LookupOutput"]), stage6_field_expr("stage6.ram_ra_virtual.output.product.RamRa.partial0", Stage6FieldExprKind::Mul, &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1"]), stage6_field_expr("stage6.ram_ra_virtual.output.product.RamRa.partial1", Stage6FieldExprKind::Mul, &["stage6.ram_ra_virtual.output.product.RamRa.partial0", "stage6.ram_ra_virtual.eval.RamRa_2"]), stage6_field_expr("stage6.ram_ra_virtual.output.product.RamRa.partial2", Stage6FieldExprKind::Mul, &["stage6.ram_ra_virtual.output.product.RamRa.partial1", "stage6.ram_ra_virtual.eval.RamRa_3"]), stage6_field_expr("stage6.ram_ra_virtual.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.ram_ra_virtual.output.eq.Cycle", "stage6.ram_ra_virtual.output.product.RamRa.partial2"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_1", "stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial2"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_10"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_11"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_2", "stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_14"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_15"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_3", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_18"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_19"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_4", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_22"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_23"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_5", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_26"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_27"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_6", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_30"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_31"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_7", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial0", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial2", "stage6.instruction_ra_virtual.output.term.InstructionRa_1"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial0", "stage6.instruction_ra_virtual.output.term.InstructionRa_2"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial1", "stage6.instruction_ra_virtual.output.term.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial2", "stage6.instruction_ra_virtual.output.term.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial3", "stage6.instruction_ra_virtual.output.term.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial4", "stage6.instruction_ra_virtual.output.term.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial5", "stage6.instruction_ra_virtual.output.term.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.eq.Cycle", "stage6.instruction_ra_virtual.output.weighted_sum.partial6"]), stage6_field_expr("stage6.inc_claim_reduction.output.term.RamIncStage4", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.gamma", "stage6.inc_claim_reduction.output.eq.RamIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.eq.RamCombined", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.term.RamIncStage4"]), + stage6_field_expr("stage6.inc_claim_reduction.output.term.RamInc", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.eq.RamCombined"]), stage6_field_expr("stage6.inc_claim_reduction.output.term.RdIncStage5", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.gamma", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.eq.RdCombined", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.output.eq.RdIncStage4", "stage6.inc_claim_reduction.output.term.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.term.RdInc", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.eq.RdCombined"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term.RdWeighted", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.output.gamma2", "stage6.inc_claim_reduction.output.term.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.output.term.RamInc", "stage6.inc_claim_reduction.output.term.RdWeighted"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -597,6 +612,32 @@ pub const STAGE6_OPENING_EQUALITIES: &[Stage6OpeningClaimEqualityPlan] = &[ pub const STAGE6_OPENING_BATCHES: &[Stage6OpeningBatchPlan] = &[ Stage6OpeningBatchPlan { symbol: "stage6.openings", stage: "stage6", proof_slot: "stage6.openings", policy: "jolt_stage6_output_order", count: 81, ordered_claims: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"], claim_operands: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"] }, ]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.hamming_booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage1.LookupOutput", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse } }, +]; + +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.ram_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, +]; + +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.instruction_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, +]; + +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage2.ram_read_write.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.ram_val_check.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.registers_read_write.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.registers_val_evaluation.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, +]; + +pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[ + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage6.hamming_booleanity.output.claim_expr" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage6.ram_ra_virtual.output.claim_expr" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, claim_value: "stage6.instruction_ra_virtual.output.claim_expr" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, claim_value: "stage6.inc_claim_reduction.output.claim_expr" }, +]; + pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { role: "verifier", params: STAGE6_PARAMS, @@ -612,6 +653,7 @@ pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { drivers: STAGE6_SUMCHECK_DRIVERS, instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS, evals: STAGE6_SUMCHECK_EVALS, + output_claims: STAGE6_SUMCHECK_OUTPUT_CLAIMS, point_zeros: STAGE6_POINT_ZEROS, point_slices: STAGE6_POINT_SLICES, point_concats: STAGE6_POINT_CONCATS, @@ -909,18 +951,16 @@ fn expected_batched_output_claim( Stage6RelationKind::Stage6Booleanity => { expected_booleanity(program, store, evals, local_point)? } - Stage6RelationKind::Stage6HammingBooleanity => { - expected_hamming_booleanity(store, evals, local_point)? - } - Stage6RelationKind::Stage6RamRaVirtual => { - expected_ram_ra_virtual(store, evals, local_point)? - } - Stage6RelationKind::Stage6InstructionRaVirtual => { - expected_instruction_ra_virtual(program, store, evals, local_point)? - } - Stage6RelationKind::Stage6IncClaimReduction => { - expected_inc_claim_reduction(store, evals, local_point)? - } + Stage6RelationKind::Stage6HammingBooleanity + | Stage6RelationKind::Stage6RamRaVirtual + | Stage6RelationKind::Stage6InstructionRaVirtual + | Stage6RelationKind::Stage6IncClaimReduction => expected_plan_output_claim( + program, + instance, + store, + evals, + local_point, + )?, relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }), }; expected += *coefficient * value; @@ -928,6 +968,30 @@ fn expected_batched_output_claim( Ok(expected) } +fn expected_plan_output_claim( + program: &'static Stage6VerifierProgramPlan, + instance: &'static Stage6SumcheckInstanceResultPlan, + store: &bolt_verifier_runtime::ValueStore, + evals: &[Stage6NamedEval], + local_point: &[Fr], +) -> Result { + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage6Error::UnsupportedRelation { + relation: instance.relation, + })?; + Ok(bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )?) +} + fn expected_bytecode_read_raf( program: &'static Stage6VerifierProgramPlan, data: &Stage6BytecodeReadRafData, @@ -958,39 +1022,6 @@ fn expected_booleanity( Ok(expected_stage67_booleanity(store, evals, local_point, log_t, &STAGE6_RELATION_SYMBOLS)?) } -fn expected_hamming_booleanity( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - Ok(expected_stage67_hamming_booleanity(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?) -} - -fn expected_ram_ra_virtual( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - Ok(expected_stage67_ram_ra_virtual(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?) -} - -fn expected_instruction_ra_virtual( - program: &'static Stage6VerifierProgramPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - Ok(expected_stage67_instruction_ra_virtual(program.opening_inputs, store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?) -} - -fn expected_inc_claim_reduction( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - Ok(expected_stage67_inc_claim_reduction(store, evals, local_point, &STAGE6_RELATION_SYMBOLS)?) -} - fn stage6_trace_rounds( program: &'static Stage6VerifierProgramPlan, ) -> Result { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 67c1785aae..c6c30c43e4 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -322,6 +322,7 @@ pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan { drivers: STAGE7_SUMCHECK_DRIVERS, instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS, evals: STAGE7_SUMCHECK_EVALS, + output_claims: &[], point_zeros: STAGE7_POINT_ZEROS, point_slices: STAGE7_POINT_SLICES, point_concats: STAGE7_POINT_CONCATS, From ca21d6d5b43d5937ad0911988aa954c3bd911ef0 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 15:30:06 -0600 Subject: [PATCH 028/171] refactor(bolt): share output claim emission Extract shared compiler-side structured output-claim parsing, validation, pruning, and Rust constant emission for Stage 3 through Stage 6. Preserve generated verifier artifacts while removing duplicated stage-local emitter scaffolding. --- .../bolt/src/protocols/jolt/emit/rust/mod.rs | 1 + .../protocols/jolt/emit/rust/output_claims.rs | 360 +++++++++++++++++ .../src/protocols/jolt/emit/rust/stage3.rs | 329 ++-------------- .../src/protocols/jolt/emit/rust/stage4.rs | 365 +++-------------- .../src/protocols/jolt/emit/rust/stage5.rs | 365 +++-------------- .../src/protocols/jolt/emit/rust/stage6.rs | 367 +++--------------- 6 files changed, 577 insertions(+), 1210 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/mod.rs b/crates/bolt/src/protocols/jolt/emit/rust/mod.rs index 00b7be9f4c..b2ec52fa0c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/mod.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/mod.rs @@ -1,4 +1,5 @@ mod commitment; +mod output_claims; mod plan_tokens; mod stage1; mod stage2; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs new file mode 100644 index 0000000000..be8572da50 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -0,0 +1,360 @@ +use std::collections::{BTreeMap, BTreeSet}; + +use crate::emit::rust::{push_format, EmitError}; +use crate::ir::Role; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct StructuredPolynomialPointPlan { + pub source: String, + pub segment: String, + pub length: String, + pub order: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct StructuredPolynomialEvalPlan { + pub symbol: String, + pub polynomial: String, + pub x_point: StructuredPolynomialPointPlan, + pub y_point: StructuredPolynomialPointPlan, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputClaimPlan { + pub relation: String, + pub polynomial_evals: Vec, + pub claim_value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputClaimAst { + pub relation: String, + pub polynomial_evals: Vec, + pub polynomial_eval_operands: Vec, + pub claim_value: String, +} + +pub trait FieldExprDependencies { + fn symbol(&self) -> &str; + fn operands(&self) -> &[String]; +} + +pub fn resolve_output_claims( + stage: &str, + output_values: &[StructuredPolynomialEvalPlan], + claim_asts: Vec, +) -> Result, EmitError> { + let output_values_by_symbol: BTreeMap<_, _> = output_values + .iter() + .map(|value| (value.symbol.as_str(), value)) + .collect(); + claim_asts + .into_iter() + .map(|claim| { + verify_count( + "sumcheck output claim polynomial_evals", + &claim.relation, + claim.polynomial_evals.len(), + claim.polynomial_eval_operands.len(), + )?; + if claim.polynomial_evals != claim.polynomial_eval_operands { + return Err(EmitError::new(format!( + "{stage} output claim for @{} polynomial_evals do not match operands", + claim.relation + ))); + } + let polynomial_evals = claim + .polynomial_evals + .iter() + .map(|symbol| { + output_values_by_symbol + .get(symbol.as_str()) + .copied() + .cloned() + .ok_or_else(|| { + EmitError::new(format!( + "{stage} output claim for @{} references missing output value @{symbol}", + claim.relation + )) + }) + }) + .collect::, EmitError>>()?; + Ok(SumcheckOutputClaimPlan { + relation: claim.relation, + polynomial_evals, + claim_value: claim.claim_value, + }) + }) + .collect() +} + +pub fn prune_output_only_field_exprs<'a, 'b, T>( + field_exprs: &mut Vec, + sumcheck_claim_roots: impl Iterator, + output_claim_roots: impl Iterator, +) where + T: FieldExprDependencies, +{ + let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs + .iter() + .map(|expr| (expr.symbol(), expr)) + .collect(); + let sumcheck_claim_closure = + field_expr_dependency_closure(&field_exprs_by_symbol, sumcheck_claim_roots); + let output_claim_closure = + field_expr_dependency_closure(&field_exprs_by_symbol, output_claim_roots); + field_exprs.retain(|expr| { + !output_claim_closure.contains(expr.symbol()) + || sumcheck_claim_closure.contains(expr.symbol()) + }); +} + +pub fn verify_output_claims( + stage: &str, + output_values: &[StructuredPolynomialEvalPlan], + output_claims: &[SumcheckOutputClaimPlan], + relations: &BTreeSet, + field_values: &BTreeSet, + point_values: &BTreeSet, +) -> Result<(), EmitError> { + for polynomial_eval in output_values { + if !point_values.contains(&polynomial_eval.x_point.source) { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} references missing x-point @{}", + polynomial_eval.symbol, polynomial_eval.x_point.source + ))); + } + if !point_values.contains(&polynomial_eval.y_point.source) { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} references missing y-point @{}", + polynomial_eval.symbol, polynomial_eval.y_point.source + ))); + } + if !matches!( + polynomial_eval.polynomial.as_str(), + "eq" | "eq_plus_one" | "lt" + ) { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported polynomial `{}`", + polynomial_eval.symbol, polynomial_eval.polynomial + ))); + } + verify_structured_polynomial_point_plan(stage, polynomial_eval, &polynomial_eval.x_point)?; + verify_structured_polynomial_point_plan(stage, polynomial_eval, &polynomial_eval.y_point)?; + } + for claim in output_claims { + if !relations.contains(&claim.relation) { + return Err(EmitError::new(format!( + "{stage} output claim references missing relation @{}", + claim.relation + ))); + } + if !field_values.contains(&claim.claim_value) { + return Err(EmitError::new(format!( + "{stage} output claim for @{} uses missing claim value @{}", + claim.relation, claim.claim_value + ))); + } + } + Ok(()) +} + +pub fn emit_verifier_output_claim_constants( + stage_type: &str, + role: &Role, + output_claims: &[SumcheckOutputClaimPlan], +) -> Result { + let mut source = String::new(); + let mut claims = Vec::new(); + for (index, claim) in output_claims.iter().enumerate() { + let values_name = format!( + "{}_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES", + stage_type.to_ascii_uppercase() + ); + let values = claim + .polynomial_evals + .iter() + .map(|value| { + Ok(format!( + " {stage_type}StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", + rust_str(&value.symbol), + structured_polynomial_kind_expr(stage_type, &value.polynomial)?, + structured_polynomial_point_expr(stage_type, &value.x_point)?, + structured_polynomial_point_expr(stage_type, &value.y_point)?, + )) + }) + .collect::, EmitError>>()? + .join("\n"); + push_format( + &mut source, + format_args!( + "pub const {values_name}: &[{stage_type}StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" + ), + ); + claims.push(format!( + " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, claim_value: {} }},", + super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, + rust_str(&claim.claim_value) + )); + } + let claims = claims.join("\n"); + let claims_name = format!("{}_SUMCHECK_OUTPUT_CLAIMS", stage_type.to_ascii_uppercase()); + push_format( + &mut source, + format_args!( + "pub const {claims_name}: &[{stage_type}SumcheckOutputClaimPlan] = &[\n{claims}\n];\n\n" + ), + ); + Ok(source) +} + +fn field_expr_dependency_closure<'a, T>( + field_exprs_by_symbol: &BTreeMap<&str, &T>, + roots: impl Iterator, +) -> BTreeSet +where + T: FieldExprDependencies, +{ + let mut visited = BTreeSet::new(); + let mut stack = roots.map(str::to_owned).collect::>(); + while let Some(symbol) = stack.pop() { + if !visited.insert(symbol.clone()) { + continue; + } + let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { + continue; + }; + for operand in expr.operands() { + if field_exprs_by_symbol.contains_key(operand.as_str()) { + stack.push(operand.clone()); + } + } + } + visited +} + +fn verify_structured_polynomial_point_plan( + stage: &str, + polynomial_eval: &StructuredPolynomialEvalPlan, + point: &StructuredPolynomialPointPlan, +) -> Result<(), EmitError> { + if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point segment `{}`", + polynomial_eval.symbol, point.segment + ))); + } + if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point length `{}`", + polynomial_eval.symbol, point.length + ))); + } + if !matches!(point.order.as_str(), "as_is" | "reverse") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point order `{}`", + polynomial_eval.symbol, point.order + ))); + } + Ok(()) +} + +fn structured_polynomial_kind_expr( + stage_type: &str, + polynomial: &str, +) -> Result { + let variant = match polynomial { + "eq" => "Eq", + "eq_plus_one" => "EqPlusOne", + "lt" => "Lt", + _ => { + return Err(EmitError::new(format!( + "unsupported {stage_type} structured polynomial `{polynomial}`" + ))) + } + }; + Ok(format!("{stage_type}StructuredPolynomialKind::{variant}")) +} + +fn structured_polynomial_point_expr( + stage_type: &str, + point: &StructuredPolynomialPointPlan, +) -> Result { + Ok(format!( + "{stage_type}StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", + rust_str(&point.source), + structured_polynomial_point_segment_expr(stage_type, &point.segment)?, + structured_polynomial_point_length_expr(stage_type, &point.length)?, + structured_polynomial_point_order_expr(stage_type, &point.order)?, + )) +} + +fn structured_polynomial_point_segment_expr( + stage_type: &str, + segment: &str, +) -> Result { + let variant = match segment { + "full" => "Full", + "prefix" => "Prefix", + "suffix" => "Suffix", + _ => { + return Err(EmitError::new(format!( + "unsupported {stage_type} output point segment `{segment}`" + ))) + } + }; + Ok(format!( + "{stage_type}StructuredPolynomialPointSegment::{variant}" + )) +} + +fn structured_polynomial_point_length_expr( + stage_type: &str, + length: &str, +) -> Result { + let variant = match length { + "full" => "Full", + "x_point" => "XPoint", + "y_point" => "YPoint", + _ => { + return Err(EmitError::new(format!( + "unsupported {stage_type} structured polynomial point length `{length}`" + ))) + } + }; + Ok(format!( + "{stage_type}StructuredPolynomialPointLength::{variant}" + )) +} + +fn structured_polynomial_point_order_expr( + stage_type: &str, + order: &str, +) -> Result { + let variant = match order { + "as_is" => "AsIs", + "reverse" => "Reverse", + _ => { + return Err(EmitError::new(format!( + "unsupported {stage_type} output point order `{order}`" + ))) + } + }; + Ok(format!( + "{stage_type}StructuredPolynomialPointOrder::{variant}" + )) +} + +fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Result<(), EmitError> { + if expected == actual { + Ok(()) + } else { + Err(EmitError::new(format!( + "{kind} @{symbol} count mismatch: expected {expected}, got {actual}" + ))) + } +} + +fn rust_str(value: &str) -> String { + format!("{value:?}") +} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index ac693df897..1eedde23e6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -4,6 +4,12 @@ use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; +use super::output_claims::{ + FieldExprDependencies, StructuredPolynomialEvalPlan as Stage3StructuredPolynomialEvalPlan, + StructuredPolynomialPointPlan as Stage3StructuredPolynomialPointPlan, + SumcheckOutputClaimAst as Stage3SumcheckOutputClaimAst, + SumcheckOutputClaimPlan as Stage3SumcheckOutputClaimPlan, +}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::schema::verify_cpu_schema; @@ -89,6 +95,16 @@ pub struct Stage3FieldExprPlan { pub operands: Vec, } +impl FieldExprDependencies for Stage3FieldExprPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn operands(&self) -> &[String] { + &self.operands + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage3SumcheckClaimPlan { pub symbol: String, @@ -147,37 +163,6 @@ pub struct Stage3SumcheckInstanceResultPlan { pub degree: usize, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3StructuredPolynomialPointPlan { - pub source: String, - pub segment: String, - pub length: String, - pub order: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3StructuredPolynomialEvalPlan { - pub symbol: String, - pub polynomial: String, - pub x_point: Stage3StructuredPolynomialPointPlan, - pub y_point: Stage3StructuredPolynomialPointPlan, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3SumcheckOutputClaimPlan { - pub relation: String, - pub polynomial_evals: Vec, - pub claim_value: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -struct Stage3SumcheckOutputClaimAst { - relation: String, - claim_value: String, - polynomial_evals: Vec, - polynomial_eval_operands: Vec, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage3SumcheckEvalPlan { pub symbol: String, @@ -561,10 +546,20 @@ impl Stage3CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; if role == Role::Prover { - prune_prover_output_field_exprs(&mut field_exprs, &claims, &output_claim_asts); + super::output_claims::prune_output_only_field_exprs( + &mut field_exprs, + claims.iter().map(|claim| claim.claim_value.as_str()), + output_claim_asts + .iter() + .map(|claim| claim.claim_value.as_str()), + ); } let output_claims = if role == Role::Verifier { - resolve_stage3_output_claims(&output_values, output_claim_asts)? + super::output_claims::resolve_output_claims( + "stage3", + &output_values, + output_claim_asts, + )? } else { Vec::new() }; @@ -880,54 +875,14 @@ impl Stage3CpuProgram { ); let field_values = self.field_value_symbols(); let point_values = self.point_value_symbols(); - for polynomial_eval in &self.output_values { - if !point_values.contains(&polynomial_eval.x_point.source) { - return Err(EmitError::new(format!( - "stage3 structured polynomial eval @{} references missing x-point @{}", - polynomial_eval.symbol, polynomial_eval.x_point.source - ))); - } - if !point_values.contains(&polynomial_eval.y_point.source) { - return Err(EmitError::new(format!( - "stage3 structured polynomial eval @{} references missing y-point @{}", - polynomial_eval.symbol, polynomial_eval.y_point.source - ))); - } - if !matches!( - polynomial_eval.polynomial.as_str(), - "eq" | "eq_plus_one" | "lt" - ) { - return Err(EmitError::new(format!( - "stage3 structured polynomial eval @{} has unsupported polynomial `{}`", - polynomial_eval.symbol, polynomial_eval.polynomial - ))); - } - verify_structured_polynomial_point_plan( - "stage3", - polynomial_eval, - &polynomial_eval.x_point, - )?; - verify_structured_polynomial_point_plan( - "stage3", - polynomial_eval, - &polynomial_eval.y_point, - )?; - } - for claim in &self.output_claims { - if !relations.contains(&claim.relation) { - return Err(EmitError::new(format!( - "stage3 output claim references missing relation @{}", - claim.relation - ))); - } - if !field_values.contains(&claim.claim_value) { - return Err(EmitError::new(format!( - "stage3 output claim for @{} uses missing claim value @{}", - claim.relation, claim.claim_value - ))); - } - } - Ok(()) + super::output_claims::verify_output_claims( + "stage3", + &self.output_values, + &self.output_claims, + &relations, + &field_values, + &point_values, + ) } fn verify_opening_flow(&self) -> Result<(), EmitError> { @@ -1695,44 +1650,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_verifier_output_claim_constants(&self) -> Result { - let mut source = String::new(); - let mut claims = Vec::new(); - for (index, claim) in self.output_claims.iter().enumerate() { - let values_name = format!("STAGE3_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES"); - let values = claim - .polynomial_evals - .iter() - .map(|value| { - Ok(format!( - " Stage3StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", - rust_str(&value.symbol), - stage3_structured_polynomial_kind_expr(&value.polynomial)?, - stage3_structured_polynomial_point_expr(&value.x_point)?, - stage3_structured_polynomial_point_expr(&value.y_point)?, - )) - }) - .collect::, EmitError>>()? - .join("\n"); - push_format( - &mut source, - format_args!( - "pub const {values_name}: &[Stage3StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" - ), - ); - claims.push(format!( - " Stage3SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, claim_value: {} }},", - super::plan_tokens::role_relation_kind_expr("Stage3", &self.role, &claim.relation)?, - rust_str(&claim.claim_value) - )); - } - let claims = claims.join("\n"); - push_format( - &mut source, - format_args!( - "pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[\n{claims}\n];\n\n" - ), - ); - Ok(source) + super::output_claims::emit_verifier_output_claim_constants( + "Stage3", + &self.role, + &self.output_claims, + ) } fn emit_point_slice_constants(&self) -> String { @@ -2201,175 +2123,6 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } -fn resolve_stage3_output_claims( - output_values: &[Stage3StructuredPolynomialEvalPlan], - claim_asts: Vec, -) -> Result, EmitError> { - let output_values_by_symbol: BTreeMap<_, _> = output_values - .iter() - .map(|value| (value.symbol.as_str(), value)) - .collect(); - claim_asts - .into_iter() - .map(|claim| { - if claim.polynomial_evals != claim.polynomial_eval_operands { - return Err(EmitError::new(format!( - "stage3 output claim for @{} operand order does not match polynomial_evals", - claim.relation - ))); - } - let polynomial_evals = claim - .polynomial_evals - .iter() - .map(|symbol| { - output_values_by_symbol - .get(symbol.as_str()) - .map(|value| (*value).clone()) - .ok_or_else(|| { - EmitError::new(format!( - "stage3 output claim for @{} references missing output value @{symbol}", - claim.relation - )) - }) - }) - .collect::, EmitError>>()?; - Ok(Stage3SumcheckOutputClaimPlan { - relation: claim.relation, - polynomial_evals, - claim_value: claim.claim_value, - }) - }) - .collect() -} - -fn prune_prover_output_field_exprs( - field_exprs: &mut Vec, - claims: &[Stage3SumcheckClaimPlan], - output_claims: &[Stage3SumcheckOutputClaimAst], -) { - let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs - .iter() - .map(|expr| (expr.symbol.as_str(), expr)) - .collect(); - let sumcheck_claim_closure = field_expr_dependency_closure( - &field_exprs_by_symbol, - claims.iter().map(|claim| claim.claim_value.as_str()), - ); - let output_claim_closure = field_expr_dependency_closure( - &field_exprs_by_symbol, - output_claims.iter().map(|claim| claim.claim_value.as_str()), - ); - field_exprs.retain(|expr| { - !output_claim_closure.contains(&expr.symbol) - || sumcheck_claim_closure.contains(&expr.symbol) - }); -} - -fn field_expr_dependency_closure<'a>( - field_exprs_by_symbol: &BTreeMap<&str, &Stage3FieldExprPlan>, - roots: impl Iterator, -) -> BTreeSet { - let mut visited = BTreeSet::new(); - let mut stack = roots.map(str::to_owned).collect::>(); - while let Some(symbol) = stack.pop() { - if !visited.insert(symbol.clone()) { - continue; - } - let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { - continue; - }; - for operand in &expr.operands { - if field_exprs_by_symbol.contains_key(operand.as_str()) { - stack.push(operand.clone()); - } - } - } - visited -} - -fn verify_structured_polynomial_point_plan( - stage: &str, - polynomial_eval: &Stage3StructuredPolynomialEvalPlan, - point: &Stage3StructuredPolynomialPointPlan, -) -> Result<(), EmitError> { - if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point segment `{}`", - polynomial_eval.symbol, point.segment - ))); - } - if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point length `{}`", - polynomial_eval.symbol, point.length - ))); - } - if !matches!(point.order.as_str(), "as_is" | "reverse") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point order `{}`", - polynomial_eval.symbol, point.order - ))); - } - Ok(()) -} - -fn stage3_structured_polynomial_kind_expr(polynomial: &str) -> Result<&'static str, EmitError> { - match polynomial { - "eq" => Ok("Stage3StructuredPolynomialKind::Eq"), - "eq_plus_one" => Ok("Stage3StructuredPolynomialKind::EqPlusOne"), - "lt" => Ok("Stage3StructuredPolynomialKind::Lt"), - _ => Err(EmitError::new(format!( - "unsupported stage3 structured polynomial `{polynomial}`" - ))), - } -} - -fn stage3_structured_polynomial_point_expr( - point: &Stage3StructuredPolynomialPointPlan, -) -> Result { - Ok(format!( - "Stage3StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", - rust_str(&point.source), - stage3_structured_polynomial_point_segment_expr(&point.segment)?, - stage3_structured_polynomial_point_length_expr(&point.length)?, - stage3_structured_polynomial_point_order_expr(&point.order)?, - )) -} - -fn stage3_structured_polynomial_point_segment_expr( - segment: &str, -) -> Result<&'static str, EmitError> { - match segment { - "full" => Ok("Stage3StructuredPolynomialPointSegment::Full"), - "prefix" => Ok("Stage3StructuredPolynomialPointSegment::Prefix"), - "suffix" => Ok("Stage3StructuredPolynomialPointSegment::Suffix"), - _ => Err(EmitError::new(format!( - "unsupported stage3 output point segment `{segment}`" - ))), - } -} - -fn stage3_structured_polynomial_point_length_expr(length: &str) -> Result<&'static str, EmitError> { - match length { - "full" => Ok("Stage3StructuredPolynomialPointLength::Full"), - "x_point" => Ok("Stage3StructuredPolynomialPointLength::XPoint"), - "y_point" => Ok("Stage3StructuredPolynomialPointLength::YPoint"), - _ => Err(EmitError::new(format!( - "unsupported stage3 structured polynomial point length `{length}`" - ))), - } -} - -fn stage3_structured_polynomial_point_order_expr(order: &str) -> Result<&'static str, EmitError> { - match order { - "as_is" => Ok("Stage3StructuredPolynomialPointOrder::AsIs"), - "reverse" => Ok("Stage3StructuredPolynomialPointOrder::Reverse"), - _ => Err(EmitError::new(format!( - "unsupported stage3 output point order `{order}`" - ))), - } -} - fn emit_str_array(name: &str, values: &[String]) -> String { if values.is_empty() { return format!("pub const {name}: &[&str] = &[];\n\n"); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 9c063c7455..9deafca702 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -9,6 +9,12 @@ use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; +use super::output_claims::{ + FieldExprDependencies, StructuredPolynomialEvalPlan as Stage4StructuredPolynomialEvalPlan, + StructuredPolynomialPointPlan as Stage4StructuredPolynomialPointPlan, + SumcheckOutputClaimAst as Stage4SumcheckOutputClaimAst, + SumcheckOutputClaimPlan as Stage4SumcheckOutputClaimPlan, +}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::schema::verify_cpu_schema; @@ -102,6 +108,16 @@ pub struct Stage4FieldExprPlan { pub operands: Vec, } +impl FieldExprDependencies for Stage4FieldExprPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn operands(&self) -> &[String] { + &self.operands + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage4SumcheckClaimPlan { pub symbol: String, @@ -169,37 +185,6 @@ pub struct Stage4SumcheckEvalPlan { pub oracle: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4StructuredPolynomialPointPlan { - pub source: String, - pub segment: String, - pub length: String, - pub order: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4StructuredPolynomialEvalPlan { - pub symbol: String, - pub polynomial: String, - pub x_point: Stage4StructuredPolynomialPointPlan, - pub y_point: Stage4StructuredPolynomialPointPlan, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4SumcheckOutputClaimPlan { - pub relation: String, - pub polynomial_evals: Vec, - pub claim_value: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -struct Stage4SumcheckOutputClaimAst { - relation: String, - polynomial_evals: Vec, - polynomial_eval_operands: Vec, - claim_value: String, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage4PointSlicePlan { pub symbol: String, @@ -572,10 +557,20 @@ impl Stage4CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; if role == Role::Prover { - prune_prover_output_field_exprs(&mut field_exprs, &claims, &output_claim_asts); + super::output_claims::prune_output_only_field_exprs( + &mut field_exprs, + claims.iter().map(|claim| claim.claim_value.as_str()), + output_claim_asts + .iter() + .map(|claim| claim.claim_value.as_str()), + ); } let output_claims = if role == Role::Verifier { - resolve_stage4_output_claims(&output_values, output_claim_asts)? + super::output_claims::resolve_output_claims( + "stage4", + &output_values, + output_claim_asts, + )? } else { Vec::new() }; @@ -705,6 +700,22 @@ impl Stage4CpuProgram { values } + fn point_value_symbols(&self) -> BTreeSet { + let mut values = symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + ); + values.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + values.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + values + } + fn verify_kernel_definitions(&self) -> Result<(), EmitError> { for kernel in &self.kernels { if kernel.backend != "cpu" { @@ -884,66 +895,15 @@ impl Stage4CpuProgram { .map(|instance| &instance.relation), ); let field_values = self.field_value_symbols(); - let mut point_values = symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - ); - point_values.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_values.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); - for polynomial_eval in &self.output_values { - if !point_values.contains(&polynomial_eval.x_point.source) { - return Err(EmitError::new(format!( - "stage4 structured polynomial eval @{} references missing x-point @{}", - polynomial_eval.symbol, polynomial_eval.x_point.source - ))); - } - if !point_values.contains(&polynomial_eval.y_point.source) { - return Err(EmitError::new(format!( - "stage4 structured polynomial eval @{} references missing y-point @{}", - polynomial_eval.symbol, polynomial_eval.y_point.source - ))); - } - if !matches!( - polynomial_eval.polynomial.as_str(), - "eq" | "eq_plus_one" | "lt" - ) { - return Err(EmitError::new(format!( - "stage4 structured polynomial eval @{} has unsupported polynomial `{}`", - polynomial_eval.symbol, polynomial_eval.polynomial - ))); - } - verify_structured_polynomial_point_plan( - "stage4", - polynomial_eval, - &polynomial_eval.x_point, - )?; - verify_structured_polynomial_point_plan( - "stage4", - polynomial_eval, - &polynomial_eval.y_point, - )?; - } - for claim in &self.output_claims { - if !relations.contains(&claim.relation) { - return Err(EmitError::new(format!( - "stage4 output claim references missing relation @{}", - claim.relation - ))); - } - if !field_values.contains(&claim.claim_value) { - return Err(EmitError::new(format!( - "stage4 output claim for @{} uses missing claim value @{}", - claim.relation, claim.claim_value - ))); - } - } - Ok(()) + let point_values = self.point_value_symbols(); + super::output_claims::verify_output_claims( + "stage4", + &self.output_values, + &self.output_claims, + &relations, + &field_values, + &point_values, + ) } fn verify_opening_flow(&self) -> Result<(), EmitError> { @@ -1894,44 +1854,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } fn emit_verifier_output_claim_constants(&self) -> Result { - let mut source = String::new(); - let mut claims = Vec::new(); - for (index, claim) in self.output_claims.iter().enumerate() { - let values_name = format!("STAGE4_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES"); - let values = claim - .polynomial_evals - .iter() - .map(|value| { - Ok(format!( - " Stage4StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", - rust_str(&value.symbol), - stage4_structured_polynomial_kind_expr(&value.polynomial)?, - stage4_structured_polynomial_point_expr(&value.x_point)?, - stage4_structured_polynomial_point_expr(&value.y_point)?, - )) - }) - .collect::, EmitError>>()? - .join("\n"); - push_format( - &mut source, - format_args!( - "pub const {values_name}: &[Stage4StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" - ), - ); - claims.push(format!( - " Stage4SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, claim_value: {} }},", - super::plan_tokens::role_relation_kind_expr("Stage4", &self.role, &claim.relation)?, - rust_str(&claim.claim_value) - )); - } - let claims = claims.join("\n"); - push_format( - &mut source, - format_args!( - "pub const STAGE4_SUMCHECK_OUTPUT_CLAIMS: &[Stage4SumcheckOutputClaimPlan] = &[\n{claims}\n];\n\n" - ), - ); - Ok(source) + super::output_claims::emit_verifier_output_claim_constants( + "Stage4", + &self.role, + &self.output_claims, + ) } fn emit_point_slice_constants(&self) -> String { @@ -2461,182 +2388,6 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } -fn resolve_stage4_output_claims( - output_values: &[Stage4StructuredPolynomialEvalPlan], - claim_asts: Vec, -) -> Result, EmitError> { - let output_values_by_symbol: BTreeMap<_, _> = output_values - .iter() - .map(|value| (value.symbol.as_str(), value)) - .collect(); - claim_asts - .into_iter() - .map(|claim| { - verify_count( - "sumcheck output claim polynomial_evals", - &claim.relation, - claim.polynomial_evals.len(), - claim.polynomial_eval_operands.len(), - )?; - if claim.polynomial_evals != claim.polynomial_eval_operands { - return Err(EmitError::new(format!( - "stage4 output claim for @{} polynomial_evals do not match operands", - claim.relation - ))); - } - let polynomial_evals = claim - .polynomial_evals - .iter() - .map(|symbol| { - output_values_by_symbol - .get(symbol.as_str()) - .copied() - .cloned() - .ok_or_else(|| { - EmitError::new(format!( - "stage4 output claim for @{} references missing output value @{symbol}", - claim.relation - )) - }) - }) - .collect::, EmitError>>()?; - Ok(Stage4SumcheckOutputClaimPlan { - relation: claim.relation, - polynomial_evals, - claim_value: claim.claim_value, - }) - }) - .collect() -} - -fn prune_prover_output_field_exprs( - field_exprs: &mut Vec, - claims: &[Stage4SumcheckClaimPlan], - output_claims: &[Stage4SumcheckOutputClaimAst], -) { - let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs - .iter() - .map(|expr| (expr.symbol.as_str(), expr)) - .collect(); - let sumcheck_claim_closure = field_expr_dependency_closure( - &field_exprs_by_symbol, - claims.iter().map(|claim| claim.claim_value.as_str()), - ); - let output_claim_closure = field_expr_dependency_closure( - &field_exprs_by_symbol, - output_claims.iter().map(|claim| claim.claim_value.as_str()), - ); - field_exprs.retain(|expr| { - !output_claim_closure.contains(&expr.symbol) - || sumcheck_claim_closure.contains(&expr.symbol) - }); -} - -fn field_expr_dependency_closure<'a>( - field_exprs_by_symbol: &BTreeMap<&str, &Stage4FieldExprPlan>, - roots: impl Iterator, -) -> BTreeSet { - let mut visited = BTreeSet::new(); - let mut stack = roots.map(str::to_owned).collect::>(); - while let Some(symbol) = stack.pop() { - if !visited.insert(symbol.clone()) { - continue; - } - let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { - continue; - }; - for operand in &expr.operands { - if field_exprs_by_symbol.contains_key(operand.as_str()) { - stack.push(operand.clone()); - } - } - } - visited -} - -fn verify_structured_polynomial_point_plan( - stage: &str, - polynomial_eval: &Stage4StructuredPolynomialEvalPlan, - point: &Stage4StructuredPolynomialPointPlan, -) -> Result<(), EmitError> { - if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point segment `{}`", - polynomial_eval.symbol, point.segment - ))); - } - if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point length `{}`", - polynomial_eval.symbol, point.length - ))); - } - if !matches!(point.order.as_str(), "as_is" | "reverse") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point order `{}`", - polynomial_eval.symbol, point.order - ))); - } - Ok(()) -} - -fn stage4_structured_polynomial_kind_expr(polynomial: &str) -> Result<&'static str, EmitError> { - match polynomial { - "eq" => Ok("Stage4StructuredPolynomialKind::Eq"), - "eq_plus_one" => Ok("Stage4StructuredPolynomialKind::EqPlusOne"), - "lt" => Ok("Stage4StructuredPolynomialKind::Lt"), - _ => Err(EmitError::new(format!( - "unsupported stage4 structured polynomial `{polynomial}`" - ))), - } -} - -fn stage4_structured_polynomial_point_expr( - point: &Stage4StructuredPolynomialPointPlan, -) -> Result { - Ok(format!( - "Stage4StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", - rust_str(&point.source), - stage4_structured_polynomial_point_segment_expr(&point.segment)?, - stage4_structured_polynomial_point_length_expr(&point.length)?, - stage4_structured_polynomial_point_order_expr(&point.order)?, - )) -} - -fn stage4_structured_polynomial_point_segment_expr( - segment: &str, -) -> Result<&'static str, EmitError> { - match segment { - "full" => Ok("Stage4StructuredPolynomialPointSegment::Full"), - "prefix" => Ok("Stage4StructuredPolynomialPointSegment::Prefix"), - "suffix" => Ok("Stage4StructuredPolynomialPointSegment::Suffix"), - _ => Err(EmitError::new(format!( - "unsupported stage4 output point segment `{segment}`" - ))), - } -} - -fn stage4_structured_polynomial_point_length_expr(length: &str) -> Result<&'static str, EmitError> { - match length { - "full" => Ok("Stage4StructuredPolynomialPointLength::Full"), - "x_point" => Ok("Stage4StructuredPolynomialPointLength::XPoint"), - "y_point" => Ok("Stage4StructuredPolynomialPointLength::YPoint"), - _ => Err(EmitError::new(format!( - "unsupported stage4 structured polynomial point length `{length}`" - ))), - } -} - -fn stage4_structured_polynomial_point_order_expr(order: &str) -> Result<&'static str, EmitError> { - match order { - "as_is" => Ok("Stage4StructuredPolynomialPointOrder::AsIs"), - "reverse" => Ok("Stage4StructuredPolynomialPointOrder::Reverse"), - _ => Err(EmitError::new(format!( - "unsupported stage4 output point order `{order}`" - ))), - } -} - fn emit_str_array(name: &str, values: &[String]) -> String { if values.is_empty() { return format!("pub const {name}: &[&str] = &[];\n\n"); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index f4c5a66fbe..756f8590bf 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -9,6 +9,12 @@ use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; +use super::output_claims::{ + FieldExprDependencies, StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, + StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, + SumcheckOutputClaimAst as Stage5SumcheckOutputClaimAst, + SumcheckOutputClaimPlan as Stage5SumcheckOutputClaimPlan, +}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::schema::verify_cpu_schema; @@ -102,6 +108,16 @@ pub struct Stage5FieldExprPlan { pub operands: Vec, } +impl FieldExprDependencies for Stage5FieldExprPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn operands(&self) -> &[String] { + &self.operands + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5SumcheckClaimPlan { pub symbol: String, @@ -169,37 +185,6 @@ pub struct Stage5SumcheckEvalPlan { pub oracle: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5StructuredPolynomialPointPlan { - pub source: String, - pub segment: String, - pub length: String, - pub order: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5StructuredPolynomialEvalPlan { - pub symbol: String, - pub polynomial: String, - pub x_point: Stage5StructuredPolynomialPointPlan, - pub y_point: Stage5StructuredPolynomialPointPlan, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5SumcheckOutputClaimPlan { - pub relation: String, - pub polynomial_evals: Vec, - pub claim_value: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -struct Stage5SumcheckOutputClaimAst { - relation: String, - polynomial_evals: Vec, - polynomial_eval_operands: Vec, - claim_value: String, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5PointSlicePlan { pub symbol: String, @@ -572,10 +557,20 @@ impl Stage5CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; if role == Role::Prover { - prune_prover_output_field_exprs(&mut field_exprs, &claims, &output_claim_asts); + super::output_claims::prune_output_only_field_exprs( + &mut field_exprs, + claims.iter().map(|claim| claim.claim_value.as_str()), + output_claim_asts + .iter() + .map(|claim| claim.claim_value.as_str()), + ); } let output_claims = if role == Role::Verifier { - resolve_stage5_output_claims(&output_values, output_claim_asts)? + super::output_claims::resolve_output_claims( + "stage5", + &output_values, + output_claim_asts, + )? } else { Vec::new() }; @@ -705,6 +700,22 @@ impl Stage5CpuProgram { values } + fn point_value_symbols(&self) -> BTreeSet { + let mut values = symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + ); + values.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + values.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + values + } + fn verify_kernel_definitions(&self) -> Result<(), EmitError> { for kernel in &self.kernels { if kernel.backend != "cpu" { @@ -885,66 +896,15 @@ impl Stage5CpuProgram { .map(|instance| &instance.relation), ); let field_values = self.field_value_symbols(); - let mut point_values = symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - ); - point_values.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_values.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); - for polynomial_eval in &self.output_values { - if !point_values.contains(&polynomial_eval.x_point.source) { - return Err(EmitError::new(format!( - "stage5 structured polynomial eval @{} references missing x-point @{}", - polynomial_eval.symbol, polynomial_eval.x_point.source - ))); - } - if !point_values.contains(&polynomial_eval.y_point.source) { - return Err(EmitError::new(format!( - "stage5 structured polynomial eval @{} references missing y-point @{}", - polynomial_eval.symbol, polynomial_eval.y_point.source - ))); - } - if !matches!( - polynomial_eval.polynomial.as_str(), - "eq" | "eq_plus_one" | "lt" - ) { - return Err(EmitError::new(format!( - "stage5 structured polynomial eval @{} has unsupported polynomial `{}`", - polynomial_eval.symbol, polynomial_eval.polynomial - ))); - } - verify_structured_polynomial_point_plan( - "stage5", - polynomial_eval, - &polynomial_eval.x_point, - )?; - verify_structured_polynomial_point_plan( - "stage5", - polynomial_eval, - &polynomial_eval.y_point, - )?; - } - for claim in &self.output_claims { - if !relations.contains(&claim.relation) { - return Err(EmitError::new(format!( - "stage5 output claim references missing relation @{}", - claim.relation - ))); - } - if !field_values.contains(&claim.claim_value) { - return Err(EmitError::new(format!( - "stage5 output claim for @{} uses missing claim value @{}", - claim.relation, claim.claim_value - ))); - } - } - Ok(()) + let point_values = self.point_value_symbols(); + super::output_claims::verify_output_claims( + "stage5", + &self.output_values, + &self.output_claims, + &relations, + &field_values, + &point_values, + ) } fn verify_opening_flow(&self) -> Result<(), EmitError> { @@ -1898,44 +1858,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_verifier_output_claim_constants(&self) -> Result { - let mut source = String::new(); - let mut claims = Vec::new(); - for (index, claim) in self.output_claims.iter().enumerate() { - let values_name = format!("STAGE5_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES"); - let values = claim - .polynomial_evals - .iter() - .map(|value| { - Ok(format!( - " Stage5StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", - rust_str(&value.symbol), - stage5_structured_polynomial_kind_expr(&value.polynomial)?, - stage5_structured_polynomial_point_expr(&value.x_point)?, - stage5_structured_polynomial_point_expr(&value.y_point)?, - )) - }) - .collect::, EmitError>>()? - .join("\n"); - push_format( - &mut source, - format_args!( - "pub const {values_name}: &[Stage5StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" - ), - ); - claims.push(format!( - " Stage5SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, claim_value: {} }},", - super::plan_tokens::role_relation_kind_expr("Stage5", &self.role, &claim.relation)?, - rust_str(&claim.claim_value) - )); - } - let claims = claims.join("\n"); - push_format( - &mut source, - format_args!( - "pub const STAGE5_SUMCHECK_OUTPUT_CLAIMS: &[Stage5SumcheckOutputClaimPlan] = &[\n{claims}\n];\n\n" - ), - ); - Ok(source) + super::output_claims::emit_verifier_output_claim_constants( + "Stage5", + &self.role, + &self.output_claims, + ) } fn emit_point_slice_constants(&self) -> String { @@ -2522,182 +2449,6 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } -fn resolve_stage5_output_claims( - output_values: &[Stage5StructuredPolynomialEvalPlan], - claim_asts: Vec, -) -> Result, EmitError> { - let output_values_by_symbol: BTreeMap<_, _> = output_values - .iter() - .map(|value| (value.symbol.as_str(), value)) - .collect(); - claim_asts - .into_iter() - .map(|claim| { - verify_count( - "sumcheck output claim polynomial_evals", - &claim.relation, - claim.polynomial_evals.len(), - claim.polynomial_eval_operands.len(), - )?; - if claim.polynomial_evals != claim.polynomial_eval_operands { - return Err(EmitError::new(format!( - "stage5 output claim for @{} polynomial_evals do not match operands", - claim.relation - ))); - } - let polynomial_evals = claim - .polynomial_evals - .iter() - .map(|symbol| { - output_values_by_symbol - .get(symbol.as_str()) - .copied() - .cloned() - .ok_or_else(|| { - EmitError::new(format!( - "stage5 output claim for @{} references missing output value @{symbol}", - claim.relation - )) - }) - }) - .collect::, EmitError>>()?; - Ok(Stage5SumcheckOutputClaimPlan { - relation: claim.relation, - polynomial_evals, - claim_value: claim.claim_value, - }) - }) - .collect() -} - -fn prune_prover_output_field_exprs( - field_exprs: &mut Vec, - claims: &[Stage5SumcheckClaimPlan], - output_claims: &[Stage5SumcheckOutputClaimAst], -) { - let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs - .iter() - .map(|expr| (expr.symbol.as_str(), expr)) - .collect(); - let sumcheck_claim_closure = field_expr_dependency_closure( - &field_exprs_by_symbol, - claims.iter().map(|claim| claim.claim_value.as_str()), - ); - let output_claim_closure = field_expr_dependency_closure( - &field_exprs_by_symbol, - output_claims.iter().map(|claim| claim.claim_value.as_str()), - ); - field_exprs.retain(|expr| { - !output_claim_closure.contains(&expr.symbol) - || sumcheck_claim_closure.contains(&expr.symbol) - }); -} - -fn field_expr_dependency_closure<'a>( - field_exprs_by_symbol: &BTreeMap<&str, &Stage5FieldExprPlan>, - roots: impl Iterator, -) -> BTreeSet { - let mut visited = BTreeSet::new(); - let mut stack = roots.map(str::to_owned).collect::>(); - while let Some(symbol) = stack.pop() { - if !visited.insert(symbol.clone()) { - continue; - } - let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { - continue; - }; - for operand in &expr.operands { - if field_exprs_by_symbol.contains_key(operand.as_str()) { - stack.push(operand.clone()); - } - } - } - visited -} - -fn verify_structured_polynomial_point_plan( - stage: &str, - polynomial_eval: &Stage5StructuredPolynomialEvalPlan, - point: &Stage5StructuredPolynomialPointPlan, -) -> Result<(), EmitError> { - if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point segment `{}`", - polynomial_eval.symbol, point.segment - ))); - } - if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point length `{}`", - polynomial_eval.symbol, point.length - ))); - } - if !matches!(point.order.as_str(), "as_is" | "reverse") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point order `{}`", - polynomial_eval.symbol, point.order - ))); - } - Ok(()) -} - -fn stage5_structured_polynomial_kind_expr(polynomial: &str) -> Result<&'static str, EmitError> { - match polynomial { - "eq" => Ok("Stage5StructuredPolynomialKind::Eq"), - "eq_plus_one" => Ok("Stage5StructuredPolynomialKind::EqPlusOne"), - "lt" => Ok("Stage5StructuredPolynomialKind::Lt"), - _ => Err(EmitError::new(format!( - "unsupported stage5 structured polynomial `{polynomial}`" - ))), - } -} - -fn stage5_structured_polynomial_point_expr( - point: &Stage5StructuredPolynomialPointPlan, -) -> Result { - Ok(format!( - "Stage5StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", - rust_str(&point.source), - stage5_structured_polynomial_point_segment_expr(&point.segment)?, - stage5_structured_polynomial_point_length_expr(&point.length)?, - stage5_structured_polynomial_point_order_expr(&point.order)?, - )) -} - -fn stage5_structured_polynomial_point_segment_expr( - segment: &str, -) -> Result<&'static str, EmitError> { - match segment { - "full" => Ok("Stage5StructuredPolynomialPointSegment::Full"), - "prefix" => Ok("Stage5StructuredPolynomialPointSegment::Prefix"), - "suffix" => Ok("Stage5StructuredPolynomialPointSegment::Suffix"), - _ => Err(EmitError::new(format!( - "unsupported stage5 output point segment `{segment}`" - ))), - } -} - -fn stage5_structured_polynomial_point_length_expr(length: &str) -> Result<&'static str, EmitError> { - match length { - "full" => Ok("Stage5StructuredPolynomialPointLength::Full"), - "x_point" => Ok("Stage5StructuredPolynomialPointLength::XPoint"), - "y_point" => Ok("Stage5StructuredPolynomialPointLength::YPoint"), - _ => Err(EmitError::new(format!( - "unsupported stage5 structured polynomial point length `{length}`" - ))), - } -} - -fn stage5_structured_polynomial_point_order_expr(order: &str) -> Result<&'static str, EmitError> { - match order { - "as_is" => Ok("Stage5StructuredPolynomialPointOrder::AsIs"), - "reverse" => Ok("Stage5StructuredPolynomialPointOrder::Reverse"), - _ => Err(EmitError::new(format!( - "unsupported stage5 output point order `{order}`" - ))), - } -} - fn emit_str_array(name: &str, values: &[String]) -> String { if values.is_empty() { return format!("pub const {name}: &[&str] = &[];\n\n"); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 90cbae5237..398ef088f1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -9,6 +9,12 @@ use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; +use super::output_claims::{ + FieldExprDependencies, StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan, + StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, + SumcheckOutputClaimAst as Stage6SumcheckOutputClaimAst, + SumcheckOutputClaimPlan as Stage6SumcheckOutputClaimPlan, +}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::schema::verify_cpu_schema; @@ -103,6 +109,16 @@ pub struct Stage6FieldExprPlan { pub operands: Vec, } +impl FieldExprDependencies for Stage6FieldExprPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn operands(&self) -> &[String] { + &self.operands + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage6SumcheckClaimPlan { pub symbol: String, @@ -170,37 +186,6 @@ pub struct Stage6SumcheckEvalPlan { pub oracle: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6StructuredPolynomialPointPlan { - pub source: String, - pub segment: String, - pub length: String, - pub order: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6StructuredPolynomialEvalPlan { - pub symbol: String, - pub polynomial: String, - pub x_point: Stage6StructuredPolynomialPointPlan, - pub y_point: Stage6StructuredPolynomialPointPlan, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6SumcheckOutputClaimPlan { - pub relation: String, - pub polynomial_evals: Vec, - pub claim_value: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -struct Stage6SumcheckOutputClaimAst { - relation: String, - polynomial_evals: Vec, - polynomial_eval_operands: Vec, - claim_value: String, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage6PointZeroPlan { pub symbol: String, @@ -588,10 +573,20 @@ impl Stage6CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; if role == Role::Prover { - prune_prover_output_field_exprs(&mut field_exprs, &claims, &output_claim_asts); + super::output_claims::prune_output_only_field_exprs( + &mut field_exprs, + claims.iter().map(|claim| claim.claim_value.as_str()), + output_claim_asts + .iter() + .map(|claim| claim.claim_value.as_str()), + ); } let output_claims = if role == Role::Verifier { - resolve_stage6_output_claims(&output_values, output_claim_asts)? + super::output_claims::resolve_output_claims( + "stage6", + &output_values, + output_claim_asts, + )? } else { Vec::new() }; @@ -722,6 +717,23 @@ impl Stage6CpuProgram { values } + fn point_value_symbols(&self) -> BTreeSet { + let mut values = symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + ); + values.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + values.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); + values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + values.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + values + } + fn verify_kernel_definitions(&self) -> Result<(), EmitError> { for kernel in &self.kernels { if kernel.backend != "cpu" { @@ -905,67 +917,15 @@ impl Stage6CpuProgram { .map(|instance| &instance.relation), ); let field_values = self.field_value_symbols(); - let mut point_values = symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - ); - point_values.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_values.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); - point_values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_values.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); - for polynomial_eval in &self.output_values { - if !point_values.contains(&polynomial_eval.x_point.source) { - return Err(EmitError::new(format!( - "stage6 structured polynomial eval @{} references missing x-point @{}", - polynomial_eval.symbol, polynomial_eval.x_point.source - ))); - } - if !point_values.contains(&polynomial_eval.y_point.source) { - return Err(EmitError::new(format!( - "stage6 structured polynomial eval @{} references missing y-point @{}", - polynomial_eval.symbol, polynomial_eval.y_point.source - ))); - } - if !matches!( - polynomial_eval.polynomial.as_str(), - "eq" | "eq_plus_one" | "lt" - ) { - return Err(EmitError::new(format!( - "stage6 structured polynomial eval @{} has unsupported polynomial `{}`", - polynomial_eval.symbol, polynomial_eval.polynomial - ))); - } - verify_structured_polynomial_point_plan( - "stage6", - polynomial_eval, - &polynomial_eval.x_point, - )?; - verify_structured_polynomial_point_plan( - "stage6", - polynomial_eval, - &polynomial_eval.y_point, - )?; - } - for claim in &self.output_claims { - if !relations.contains(&claim.relation) { - return Err(EmitError::new(format!( - "stage6 output claim references missing relation @{}", - claim.relation - ))); - } - if !field_values.contains(&claim.claim_value) { - return Err(EmitError::new(format!( - "stage6 output claim for @{} uses missing claim value @{}", - claim.relation, claim.claim_value - ))); - } - } - Ok(()) + let point_values = self.point_value_symbols(); + super::output_claims::verify_output_claims( + "stage6", + &self.output_values, + &self.output_claims, + &relations, + &field_values, + &point_values, + ) } fn verify_opening_flow(&self) -> Result<(), EmitError> { @@ -2053,44 +2013,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); } fn emit_verifier_output_claim_constants(&self) -> Result { - let mut source = String::new(); - let mut claims = Vec::new(); - for (index, claim) in self.output_claims.iter().enumerate() { - let values_name = format!("STAGE6_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES"); - let values = claim - .polynomial_evals - .iter() - .map(|value| { - Ok(format!( - " Stage6StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", - rust_str(&value.symbol), - stage6_structured_polynomial_kind_expr(&value.polynomial)?, - stage6_structured_polynomial_point_expr(&value.x_point)?, - stage6_structured_polynomial_point_expr(&value.y_point)?, - )) - }) - .collect::, EmitError>>()? - .join("\n"); - push_format( - &mut source, - format_args!( - "pub const {values_name}: &[Stage6StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" - ), - ); - claims.push(format!( - " Stage6SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, claim_value: {} }},", - super::plan_tokens::role_relation_kind_expr("Stage6", &self.role, &claim.relation)?, - rust_str(&claim.claim_value) - )); - } - let claims = claims.join("\n"); - push_format( - &mut source, - format_args!( - "pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[\n{claims}\n];\n\n" - ), - ); - Ok(source) + super::output_claims::emit_verifier_output_claim_constants( + "Stage6", + &self.role, + &self.output_claims, + ) } fn emit_point_zero_constants(&self) -> String { @@ -2705,182 +2632,6 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } -fn resolve_stage6_output_claims( - output_values: &[Stage6StructuredPolynomialEvalPlan], - claim_asts: Vec, -) -> Result, EmitError> { - let output_values_by_symbol: BTreeMap<_, _> = output_values - .iter() - .map(|value| (value.symbol.as_str(), value)) - .collect(); - claim_asts - .into_iter() - .map(|claim| { - verify_count( - "sumcheck output claim polynomial_evals", - &claim.relation, - claim.polynomial_evals.len(), - claim.polynomial_eval_operands.len(), - )?; - if claim.polynomial_evals != claim.polynomial_eval_operands { - return Err(EmitError::new(format!( - "stage6 output claim for @{} polynomial_evals do not match operands", - claim.relation - ))); - } - let polynomial_evals = claim - .polynomial_evals - .iter() - .map(|symbol| { - output_values_by_symbol - .get(symbol.as_str()) - .copied() - .cloned() - .ok_or_else(|| { - EmitError::new(format!( - "stage6 output claim for @{} references missing output value @{symbol}", - claim.relation - )) - }) - }) - .collect::, EmitError>>()?; - Ok(Stage6SumcheckOutputClaimPlan { - relation: claim.relation, - polynomial_evals, - claim_value: claim.claim_value, - }) - }) - .collect() -} - -fn prune_prover_output_field_exprs( - field_exprs: &mut Vec, - claims: &[Stage6SumcheckClaimPlan], - output_claims: &[Stage6SumcheckOutputClaimAst], -) { - let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs - .iter() - .map(|expr| (expr.symbol.as_str(), expr)) - .collect(); - let sumcheck_claim_closure = field_expr_dependency_closure( - &field_exprs_by_symbol, - claims.iter().map(|claim| claim.claim_value.as_str()), - ); - let output_claim_closure = field_expr_dependency_closure( - &field_exprs_by_symbol, - output_claims.iter().map(|claim| claim.claim_value.as_str()), - ); - field_exprs.retain(|expr| { - !output_claim_closure.contains(&expr.symbol) - || sumcheck_claim_closure.contains(&expr.symbol) - }); -} - -fn field_expr_dependency_closure<'a>( - field_exprs_by_symbol: &BTreeMap<&str, &Stage6FieldExprPlan>, - roots: impl Iterator, -) -> BTreeSet { - let mut visited = BTreeSet::new(); - let mut stack = roots.map(str::to_owned).collect::>(); - while let Some(symbol) = stack.pop() { - if !visited.insert(symbol.clone()) { - continue; - } - let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { - continue; - }; - for operand in &expr.operands { - if field_exprs_by_symbol.contains_key(operand.as_str()) { - stack.push(operand.clone()); - } - } - } - visited -} - -fn verify_structured_polynomial_point_plan( - stage: &str, - polynomial_eval: &Stage6StructuredPolynomialEvalPlan, - point: &Stage6StructuredPolynomialPointPlan, -) -> Result<(), EmitError> { - if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point segment `{}`", - polynomial_eval.symbol, point.segment - ))); - } - if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point length `{}`", - polynomial_eval.symbol, point.length - ))); - } - if !matches!(point.order.as_str(), "as_is" | "reverse") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point order `{}`", - polynomial_eval.symbol, point.order - ))); - } - Ok(()) -} - -fn stage6_structured_polynomial_kind_expr(polynomial: &str) -> Result<&'static str, EmitError> { - match polynomial { - "eq" => Ok("Stage6StructuredPolynomialKind::Eq"), - "eq_plus_one" => Ok("Stage6StructuredPolynomialKind::EqPlusOne"), - "lt" => Ok("Stage6StructuredPolynomialKind::Lt"), - _ => Err(EmitError::new(format!( - "unsupported stage6 structured polynomial `{polynomial}`" - ))), - } -} - -fn stage6_structured_polynomial_point_expr( - point: &Stage6StructuredPolynomialPointPlan, -) -> Result { - Ok(format!( - "Stage6StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", - rust_str(&point.source), - stage6_structured_polynomial_point_segment_expr(&point.segment)?, - stage6_structured_polynomial_point_length_expr(&point.length)?, - stage6_structured_polynomial_point_order_expr(&point.order)?, - )) -} - -fn stage6_structured_polynomial_point_segment_expr( - segment: &str, -) -> Result<&'static str, EmitError> { - match segment { - "full" => Ok("Stage6StructuredPolynomialPointSegment::Full"), - "prefix" => Ok("Stage6StructuredPolynomialPointSegment::Prefix"), - "suffix" => Ok("Stage6StructuredPolynomialPointSegment::Suffix"), - _ => Err(EmitError::new(format!( - "unsupported stage6 output point segment `{segment}`" - ))), - } -} - -fn stage6_structured_polynomial_point_length_expr(length: &str) -> Result<&'static str, EmitError> { - match length { - "full" => Ok("Stage6StructuredPolynomialPointLength::Full"), - "x_point" => Ok("Stage6StructuredPolynomialPointLength::XPoint"), - "y_point" => Ok("Stage6StructuredPolynomialPointLength::YPoint"), - _ => Err(EmitError::new(format!( - "unsupported stage6 structured polynomial point length `{length}`" - ))), - } -} - -fn stage6_structured_polynomial_point_order_expr(order: &str) -> Result<&'static str, EmitError> { - match order { - "as_is" => Ok("Stage6StructuredPolynomialPointOrder::AsIs"), - "reverse" => Ok("Stage6StructuredPolynomialPointOrder::Reverse"), - _ => Err(EmitError::new(format!( - "unsupported stage6 output point order `{order}`" - ))), - } -} - fn emit_str_array(name: &str, values: &[String]) -> String { if values.is_empty() { return format!("pub const {name}: &[&str] = &[];\n\n"); From cdeaa879e1b28d491165b5d63f3feafc499550e1 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 16:00:40 -0600 Subject: [PATCH 029/171] docs(bolt): refine verifier refactor plan --- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 452 +++++++++++------- 1 file changed, 290 insertions(+), 162 deletions(-) diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 6ca08d72dc..e15fecf73c 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -1,6 +1,6 @@ -# Verifier Program Refactor Plan (S2 — S6) +# Verifier Program Refactor Plan -This is the implementation plan for the post-S1 verifier refactor. It is a +This is the implementation plan for the verifier-program refactor. It is a companion to `crates/bolt/GOAL.md`. Read GOAL.md first; this document assumes the `Audit Tiers` framing introduced there, but the scope is broader than follow-up LOC cleanup. @@ -21,26 +21,49 @@ Tier B (audited Jolt verifier core) stages/jolt_relations.rs 638 LOC Tier C (generated stage data + verifier.rs) 6,430 LOC ``` -S2 — S6 below progressively replace hardcoded stage-shaped Rust with typed -verifier-program data by lifting today's hand-written Rust into MLIR -vocabulary. Each slice is intended to be one reviewable PR stacked on top of the -previous one. +The current stack has already moved beyond the original S1 framing: -## Guiding principle +- `bolt-verifier-runtime` exists as a standalone crate. +- `JoltRelationKind` is owned by the Jolt verifier layer instead of the generic + runtime. +- Generated stages use typed relation enums instead of relation `&'static str` + dispatch. +- The top-level verifier executes a typed verifier-program plan. +- Structured output-claim and polynomial-eval plans have started replacing + handwritten verifier math. -> Most code in the verifier templates is an *interpreter* for plans, not -> protocol math. Lift the rest of the protocol math into MLIR vocabulary so -> the interpreter is the only thing humans need to audit. +The remaining plan is therefore **pass-first, runtime-second**. The primary +goal is not to grow a larger verifier runtime. The primary goal is to make +verifier construction a typed planning pipeline whose final Rust emission is +nearly mechanical: -Concrete corollary: **Tier A should not be per-protocol generated code at -all**. It is a small, generic interpreter that happens to be checked into -each protocol's verifier crate by historical accident. S2 corrects this. +```text +protocol / compute IR + | + v +verifier planning passes + | + v +typed CPU / Rust-plan IR + | + v +dumb Rust emission + | + v +small runtime crates for boring reusable mechanics +``` -The remaining slices (S3 — S6) close the gap between "generic interpreter" -and "Jolt-specific math evaluators" by extending the compute dialect with -the polynomial primitives, point reorderings, indexed-eval addressing, and -relation-expression vocabulary that Tier B currently fills with hand-written -Rust. +## Guiding principle + +> Verifier semantics should be resolved before Rust emission. Runtime crates are +> allowed only for boring, reusable execution mechanics. + +Concrete corollary: **`bolt-verifier-runtime` is not the architecture.** It is a +useful crate for verifier-program execution, typed value interpretation, +transcript/sumcheck/opening plumbing, and error structure. It should not become +the bucket where all common generated verifier Rust goes. If a fact is semantic, +it belongs in MLIR/codegen planning or in an explicit protocol boundary, not in a +runtime helper that reconstructs meaning from strings. Numbered stages may remain as proof-layout slots and diagnostic scopes, but they should not remain the verifier's core execution model. A generated @@ -50,42 +73,49 @@ many stage modules are hardcoded?" ## Design thesis: typed verifier IR, not better templates The plan should not optimize for making today's Rust templates shorter. The -real target is a small typed verifier IR whose Rust rendering is nearly a -serialization detail: +real target is a typed verifier-planning pipeline whose Rust rendering is +nearly a serialization detail: 1. **MLIR owns semantic facts.** If verifier execution depends on a fact, the fact should exist as a dialect op, typed attr, or typed plan field before the Rust emitter sees it. -2. **The Rust emitter projects typed plans.** It should not reconstruct protocol +2. **Planning passes own semantic assembly.** The gap between `cpu` and emitted + Rust should be filled by explicit verifier-planning passes, not by ad hoc + emitter parsing. +3. **The Rust emitter projects typed plans.** It should not reconstruct protocol meaning by parsing symbols, matching string prefixes, or emitting bespoke helper bodies that duplicate protocol math. -3. **Symbols are typed handles.** Examples in this document use `&'static str` +4. **Symbols are typed handles.** Examples in this document use `&'static str` where that keeps the prose readable, but implementation APIs should prefer `TypedPlanSymbol`-style references. Plain strings are diagnostics and serialization names, not execution contracts. -4. **The runtime interprets typed value domains.** Scalars, points, field +5. **The runtime interprets typed value domains.** Scalars, points, field vectors, eval families, relation outputs, and bytecode encodings are different verifier value kinds. Do not force point transforms or vectors into `FieldExprKind` just because field expressions exist today. -5. **Relations should be scheduled dataflow, not a second DSL.** Prefer one +6. **Relations should be scheduled dataflow, not a second DSL.** Prefer one typed verifier value graph over separate mini-interpreters for field expressions, point expressions, eval families, and relation terms. A relation check should usually be "the expected sumcheck output is scalar value X" where X is produced by the same typed graph as other verifier values. -6. **Protocol vocabulary stays at the protocol boundary.** Generic runtime code +7. **Protocol vocabulary stays at the protocol boundary.** Generic runtime code may carry opaque IDs or be generic over protocol-specific enums, but it should not define Jolt relation variants such as `Stage6BytecodeReadRaf`. -7. **No fallback execution paths.** When a typed path lands, delete the string +8. **Polynomial utilities come from `jolt-poly`.** If verifier math needs + equality, less-than, identity, Lagrange, indexed equality, or projected-bit + polynomial helpers, first use or add the right primitive in `jolt-poly`. + Do not reimplement those helpers in generated verifier Rust or runtime code. +9. **No fallback execution paths.** When a typed path lands, delete the string path in the same slice. Rollback by reverting the slice, not by keeping a compatibility parser in the verifier. -8. **Auditability beats clever compaction.** A generated table that is longer +10. **Auditability beats clever compaction.** A generated table that is longer but explains the verifier contract is better than a short table whose meaning only appears in the emitter. ## Verifier program model -The long-term runtime boundary should look like an interpreter for typed -verifier steps, not a sequence of bespoke `verify_stageN` functions: +The long-term emitted boundary should look like typed verifier-program data, +not a sequence of bespoke `verify_stageN` functions: ```rust pub struct VerifierProgramPlan { @@ -112,9 +142,9 @@ pub enum VerifierStepPlan { `SumcheckDriverPlan` is the central verifier concept. It should contain the proof slot, round schedule, input-claim plan, batching plan, output-claim emission, value/eval observation, expected-output scalar, and opening-claim -emission for one sumcheck driver. The runtime should not need to know whether a -driver came from "Stage 3" or "Stage 6" except for diagnostics and proof-record -layout. +emission for one sumcheck driver. Planning passes should assemble this shape +before Rust emission. The runtime should not need to rediscover whether a driver +came from "Stage 3" or "Stage 6" except for diagnostics and proof-record layout. Commitment receipt and PCS opening verification are first-class verifier steps, not synthetic stages. Partial verification targets should eventually be named @@ -154,12 +184,12 @@ an explicit decision, or weaker semantically. | Slice | Tier A | Tier B | Tier C | jolt-verifier total | Notes | |-------|-------:|-------:|-------:|--------------------:|-------| | post-S1 (today) | 1,265 | 638 | 6,430 | 7,905 | hard ceilings: A 1,400 / B 700 / C surface 6,100 | -| post-S2 | ~50 | 638 | 6,430 | ~6,640 | Tier A moves to `bolt-verifier-runtime` crate | -| post-S2.5 | ~150-250 | 638 | ~6,200 | ~6,900 | top-level verifier executes a typed verifier program | -| post-S3 | ~50 | <=638 | ~6,300-6,500 | ~6,500 | value graph foundation + first Stage 3/4 relation plans | -| post-S4 | ~50 | ~350 | 6,500 | ~6,500 | typed indexed-eval addressing | -| post-S5 | ~50 | ~290 | 6,700 | ~6,700 | relations as typed plans (Tier C grows) | -| post-S6 | ~50 | ~50 | 6,800 | ~6,800 | bytecode encoding as typed plans (optional) | +| current stack | ~0 in generated crate | <=700 | bounded by cleanup gates | bounded by cleanup gates | runtime extraction, typed relations, top-level verifier program, output-claim plans | +| next pass-first slice | narrow runtime | <=700 | stable or lower | stable or lower | classify runtime/codegen/poly ownership and add planning-pass seams | +| value graph | narrow runtime | <=638 | ~6,300-6,500 | ~6,500 | typed scalar/point/vector/eval-family plans | +| eval families | narrow runtime | ~350 | ~6,500 | ~6,500 | typed indexed-eval addressing | +| relation plans | narrow runtime | ~290 | ~6,700 | ~6,700 | relations as typed plans (Tier C may grow temporarily) | +| bytecode encoding | narrow runtime | ~50 | ~6,800 | ~6,800 | optional, only if audit pressure justifies it | Scoreboard numbers are planning targets for individual slices. The non-regression contracts above are stricter: the completed stack must not end @@ -168,22 +198,30 @@ post-S1 baseline. --- -## S2: Promote Tier A to `bolt-verifier-runtime` crate +## S2: Runtime extraction status and boundary correction + +**Status.** The current stack has already performed the main extraction: +`bolt-verifier-runtime` is a standalone workspace crate, generated +`jolt-verifier` depends on it, and Tier A is no longer emitted as +`stages/common.rs`. -**Goal.** Stop emitting Tier A as a per-protocol template. Instead, ship it -once as a real workspace crate that the generated `jolt-verifier` crate -declares as a Cargo dependency. +**Revised goal.** Keep that progress, but treat the crate as provisional and +narrow. The runtime is useful for boring verifier-program mechanics, but it +must not become the place where all shared generated verifier Rust accumulates. +The remaining S2 work is classification and boundary correction: -**Why first.** Largest leverage, smallest semantics change. Tier A is mostly -generic Bolt scaffolding, but it is not perfectly protocol-agnostic yet: -today it still owns Jolt-shaped IDs such as `RelationKind` and -`SourceStage::{Stage6, Stage7}` and several `Fr`-concrete helper entry points. -S2 should therefore be treated as both extraction and boundary correction, not -as proof that the runtime is already pure generic infrastructure. Once Tier A -is a real crate with an explicit public API, every subsequent slice operates -against a stable, versionable surface. +- keep generic verifier-program sequencing, value interpretation, + transcript/sumcheck/opening plumbing, and structural error types in + `bolt-verifier-runtime`; +- keep `JoltRelationKind`, bytecode contracts, RAM/register/lookup semantics, + point normalizations tied to Jolt proof layout, and other protocol math in the + Jolt layer or in typed MLIR/codegen plans; +- move reusable polynomial helpers to `jolt-poly` instead of implementing them + in the runtime; +- add CPU-to-Rust planning seams so future semantics move into passes instead + of runtime helpers or Rust emitter logic. -### Locked decisions +### Locked decisions already reflected by the current stack - `bolt-verifier-runtime` is a standalone workspace crate at `crates/bolt-verifier-runtime/`. It is not a sub-crate of `bolt` and is not @@ -225,7 +263,37 @@ against a stable, versionable surface. readability after the import cutover, but do not preserve them as API compatibility shims. -### Concrete plumbing +### Runtime boundary classification + +Keep in `bolt-verifier-runtime` only when the code is protocol-neutral +execution machinery: + +- top-level verifier-program sequencing; +- typed plan records for transcript events, sumcheck drivers, opening claims, + opening batches, and PCS checks; +- `ValueStore`-style typed value interpretation once value domains are + explicit; +- generic sumcheck verification loops; +- opening equality checks and transcript append mechanics; +- structural error reporting that can be parameterized by protocol IDs. + +Do not add to `bolt-verifier-runtime` when the code depends on Jolt protocol +meaning: + +- `JoltRelationKind` variants; +- bytecode row contracts and lookup-table semantics; +- Stage 2 RAM/product/instruction-lookup algebra; +- Stage 5 instruction read-RAF algebra; +- Stage 6/7 bytecode, hamming, RA, inc-reduction, and point-normalization + semantics; +- string-prefix eval-family lookup as a permanent API. + +If a helper is polynomial math rather than verifier mechanics, prefer +`jolt-poly`. Current candidates include less-than MLE evaluation, identity +polynomial evaluation, Lagrange basis evaluation, indexed Boolean equality, and +projected/operand polynomial evaluation. + +### Concrete plumbing already done or retained 1. New crate `crates/bolt-verifier-runtime/` with `src/lib.rs` seeded from today's `crates/bolt/src/protocols/jolt/verifier_common.rs.template`, but @@ -258,46 +326,49 @@ against a stable, versionable surface. until S2.5/S4/S5 replace that source lookup with typed verifier-program / opening-batch data. -### Test/gate updates +### Follow-up cleanup created by this revision -- `verifier_cleanup.rs` removes `bolt_runtime_loc` (it no longer counts - toward the verifier crate). Add an equivalent gate over the new crate: - `BOLT_VERIFIER_RUNTIME_LOC_CEILING ≈ 1,400`. -- `checked_in_generated_verifier_respects_boundary_hygiene` adds - `bolt-verifier-runtime` to the *allowed* import list (it is the - intentional runtime dependency). -- `commitment_ir.rs::assert_rust_source_compiles` no longer needs to stage - `common.rs` into the test harness. +1. Rename the old "runtime extraction" milestone in future PR descriptions to + "runtime boundary narrowing" or "typed planning pipeline". +2. Audit `bolt-verifier-runtime` for APIs that branch on strings or encode Jolt + protocol facts. Each such API needs one of three dispositions: typed planning + pass, Jolt verifier boundary, or `jolt-poly`. +3. Replace runtime-local polynomial helpers with `jolt-poly` calls before adding + more runtime surface. +4. Treat duplicate plan container variants in the runtime as transitional + emitter-shape leakage. Collapse them as the CPU-to-Rust plan layer becomes + explicit. +5. Do not expand the runtime to compensate for missing MLIR/codegen passes. -### Blockers and complications +### Test/gate updates -- **Cross-crate blast radius.** `jolt-equivalence` has many import sites - that name `jolt_verifier::stages::common::*`. The full-cutover rule - (workspace policy) forbids leaving back-compat re-exports, so all sites - must move to `bolt_verifier_runtime` in the same PR. Mechanical, but - large. -- **Genericity debt.** `RelationKind` and `SourceStage` are the current - strongest evidence that Tier A is not purely generic. S2 must remove both - from the runtime boundary. Do not split this into an extraction-only PR that - leaves Jolt relation variants in `bolt-verifier-runtime`. -- **Type aliases in stage files.** Generated stage files contain - `pub type Stage6FieldExprPlan = FieldExprPlan;` and similar. After S2 - the right-hand side is `bolt_verifier_runtime::FieldExprPlan`. The - per-stage Bolt emitter that produces these aliases must update its import - path and the alias targets. This is one localized change per stage - emitter. -- **`impl_runtime_plan_error_conversion!` macro.** Currently - `pub(crate) use`. Either promote to `pub` in the new crate, or keep it - per-stage by re-exporting it through `jolt-verifier`. Lean: `pub` in the - new crate. -- **Generated `Cargo.toml` dependency injection.** The Bolt manifest - emitter must learn that `bolt-verifier-runtime` is a workspace-relative - path dependency for non-published builds, but a versioned - registry dependency for published builds. Check how `jolt-field` etc. - are currently wired and follow the same pattern. -- **`cargo check` chain.** Existing CI runs - `cargo check -p bolt -p jolt-verifier -p jolt-prover -p jolt-equivalence`. - Add `-p bolt-verifier-runtime`. +- Keep `verifier_cleanup.rs` focused on the generated verifier surface, but add + or retain a separate runtime ceiling so `bolt-verifier-runtime` cannot grow + quietly. +- Keep `bolt-verifier-runtime` as the only intentional verifier runtime + dependency. The verifier remains forbidden from depending on `jolt-prover`, + `jolt-kernels`, `jolt-core`, `jolt-equivalence`, and tracing/profiling crates. +- Add targeted checks for runtime APIs that branch on string contents. Those + sites should ratchet down as S2.75/S3/S4 land. +- Add `jolt-poly` reuse checks when a helper is moved out of the runtime or + Jolt verifier core. + +### Remaining risks and complications + +- **Runtime surface creep.** The extraction solved generated-code duplication, + but the crate can still become too bespoke if it accepts every helper the + emitter wants. Treat every new runtime API as a boundary decision. +- **String-keyed transitional APIs.** `ValueStore`, eval-prefix helpers, + point-order strings, and proof/source-stage strings are useful during the + transition, but they should be removed or typed as planning passes land. +- **Duplicate plan containers.** Multiple near-duplicate stage plan structs are + signs that emitter shape leaked into the runtime. Collapse them once typed + planning output is explicit. +- **Polynomial helper ownership.** Less-than, identity, Lagrange, indexed + equality, and projected-bit polynomial helpers belong in `jolt-poly`, not in + `bolt-verifier-runtime` or generated verifier Rust. +- **Equivalence adapters.** Any plan-shape cleanup still has cross-crate blast + radius in `jolt-equivalence`; keep full-cutover discipline. ### Acceptance criteria @@ -310,30 +381,34 @@ cargo nextest run -p jolt-equivalence --test generated_role_crates --cargo-quiet cargo nextest run -p jolt-equivalence --test bolt_commitment --no-capture ``` -All green. The `verifier_cleanup` metrics output reports -`bolt_runtime_loc = 0` (Tier A no longer in the verifier crate) and a new -`bolt_verifier_runtime_loc` line. +All green. The metrics output shows Tier A remains absent from the generated +verifier crate, runtime LOC is explicitly bounded, and runtime string-dispatch +sites are reported. ### Rollback -S2 is reversible by re-introducing the `ProtocolRuntimeModule` entry for -`common` and reverting the import-path changes. The new crate can stay (it -is harmless) or be deleted. No data or proof-format changes are involved. +The extraction should not be rolled back unless the runtime boundary itself +turns out wrong. If the boundary audit overreaches, revert the specific API +deletion or helper movement rather than reintroducing generated `common.rs`. +No data or proof-format changes are involved. ### Estimated wall-clock -One overnight implementation block. The code movement is mechanical, but it -touches enough emitters, generated artifacts, tests, and equivalence adapters -that the verification matrix should be allowed to run after the import churn is -settled. +Extraction has already happened. The remaining boundary audit is one focused +agent slice, mostly classification, API deletion, `jolt-poly` reuse, and test +gate updates. --- -## S2.5: Introduce the verifier-program executor +## S2.5: Verifier-program executor status and next tightening + +**Status.** The current stack has introduced the typed top-level +`VerifierProgramPlan` and routes verifier execution through it. Keep this shape. -**Goal.** Make the top-level verifier execute a typed `VerifierProgramPlan` -instead of manually calling a fixed list of numbered stages. This slice changes -the architectural shape before the deeper algebraic cleanup starts. +**Revised goal.** Tighten the source of truth. The top-level plan should be +assembled by verifier-planning passes instead of stringly artifact glue or +emitter-side stage scans. This slice remains architectural: it changes how the +verifier is scheduled, not proof serialization. This does not require fully deleting stage modules immediately. Stage modules may still own proof-slot conversion and local plan constants at first. The @@ -420,8 +495,8 @@ flow. - Partial verification targets are typed checkpoints/proof slots. - No duplicate old/new verifier execution path remains. - Existing semantic, tamper, and import gates still pass. -- A before/after verifier-time perf baseline is captured before landing this - slice, because it changes top-level execution structure. +- Existing before/after verifier-time perf baselines remain attached to this + architectural change; future tightening slices should compare against them. ### Blockers and complications @@ -438,8 +513,54 @@ flow. ### Estimated wall-clock Two to three agent sessions. This is mostly control-flow architecture and -artifact typing, not new protocol math. It should be run after S2 and after -capturing the perf baseline. +artifact typing, not new protocol math. The current stack has already completed +the main shape; remaining work belongs in S2.75 planning-pass tightening. + +--- + +## S2.75: Add CPU-to-Rust verifier planning passes + +**Goal.** Insert an explicit planning layer between `cpu` IR and emitted Rust. +This is the main course correction from Markos' feedback: do not make the Rust +emitter or `bolt-verifier-runtime` responsible for discovering verifier +semantics. + +The current `cpu` layer still carries protocol-plan material such as stages, +proof slots, relation symbols, opening sources, point order, output claims, and +PCS policies. That is acceptable as a transitional representation, but the +Rust emitter should not parse those fields into execution meaning. It should +consume a typed Rust-plan / verifier-plan representation produced by passes. + +### Proposed passes + +1. `resolve-cpu-program-steps`: materialize ordered program steps for + transcript events, sumcheck drivers, opening-batch emission, and PCS checks. +2. `annotate-jolt-relations`: attach typed relation metadata before emission, + including relation kind, proof slot, output-evaluator strategy, external + verifier data requirements, and kernel ABI where relevant. +3. `plan-verifier-sumchecks`: lower verifier sumcheck ops plus batches and + instance results into `SumcheckDriverPlan` rows. +4. `plan-field-and-output-claims`: canonicalize field expressions, structured + polynomial evals, and output-claim equations into a typed scalar/point/value + graph. +5. `plan-opening-flow`: resolve opening inputs, claims, equalities, batches, + point/eval sources, arities, and ordering. +6. `plan-point-normalization`: replace `point_order` strings and stage-specific + point transforms with typed point-transform plans. +7. `validate-rust-target-plan`: reject unsupported field/PCS/transcript + combinations, unresolved symbols, role-specific forbidden ops, and + relation/runtime-boundary violations before the emitter runs. + +### Acceptance criteria + +- New verifier semantics are added as planning-pass output, not as Rust emitter + parsing or new runtime string dispatch. +- Relation strings are converted to typed relation IDs before Rust token + emission. +- Output-claim and point-normalization planning can be inspected without + reading emitted Rust templates. +- The Rust emitter's responsibility is mostly formatting typed const data and + importing the right runtime/Jolt-boundary APIs. --- @@ -492,7 +613,10 @@ uses ordered scalar tuples whose meaning is not a multilinear query point. ### Runtime additions -`bolt-verifier-runtime` (post-S2) gains typed value storage and interpreters: +`bolt-verifier-runtime` may retain typed value storage and interpreters, but +the planning passes should decide which values exist and how they are connected. +The runtime should evaluate typed plan rows, not infer semantics from symbol +names: ```rust pub enum VerifierValueKind { @@ -534,10 +658,11 @@ pub enum FieldVectorExprKind { ``` `ValueStore` should store each value in the correct domain. The scalar -interpreter may call `jolt-poly`'s `EqPolynomial::mle`, but point transforms -must be evaluated by the point interpreter and vector producers by the vector -interpreter. This keeps the type boundary honest and prevents the runtime from -becoming a bag of ad hoc helper functions. +interpreter should call `jolt-poly` for equality, less-than, identity, Lagrange, +and projected-bit polynomial helpers. Point transforms must be evaluated by the +point interpreter and vector producers by the vector interpreter. This keeps the +type boundary honest and prevents the runtime from becoming a bag of ad hoc +helper functions. ### Locked conversion order @@ -607,7 +732,8 @@ lowering if the dataflow ordering turns out to be subtle. ### Estimated wall-clock Two agent sessions, ~120-180 minutes total. Most of the time is in the -emitter changes (Stage 6/7 bodies) and validator updates. +planning/emitter changes for the first Stage 3/4 conversions and validator +updates. --- @@ -911,8 +1037,8 @@ If pursued: two agent sessions, ~3 hours. Otherwise zero. ### Coordination with Markos' equivalence track -Each slice that touches generated stage outputs (S2, S2.5, S3, S4, S5) will -require equivalence-side adapter updates in +Each slice that touches generated stage outputs (S2 boundary cleanup, S2.75, +S3, S4, S5) will require equivalence-side adapter updates in `crates/jolt-equivalence/src/plan_adapters/generated_stage*.rs`. The correct workflow is: @@ -933,15 +1059,18 @@ GOAL.md's "Locked Genericity Decisions" require that generic Bolt compiler infrastructure not contain Jolt-specific code, and that Jolt emitters be progressively lifted into generic CPU emitters. -S2 strengthens this only if the extraction also corrects the protocol-ID -boundary. A crate named `bolt-verifier-runtime` should not permanently define -Jolt relation variants. Either make relation/stage identifiers generic or keep -the remaining Jolt vocabulary explicitly quarantined and gated until a follow-up -removes it. +The current stack has corrected the most important protocol-ID boundary by +moving Jolt relation variants out of `bolt-verifier-runtime`. The next boundary +work is subtler: do not let the runtime or the Rust emitter become a second +home for Jolt semantics under generic names. Any branch on relation kind, +point-order spelling, eval-name prefix, source-stage string, or proof-slot +string must either become typed planning-pass output or stay visibly +quarantined in `crates/bolt/src/protocols/jolt/` / `jolt_relations.rs`. -S3 + S4 are pure compute-dialect extensions; no Jolt content. They should add a +S2.75, S3, and S4 are primarily compute/planning extensions. They should add a typed verifier value graph (`Scalar`, `Point`, `FieldVector`, eval families) -rather than a larger bag of scalar-only field-expression variants. +rather than a larger bag of scalar-only field-expression variants or runtime +string dispatch. S5 introduces `compute::relation` as generic relation metadata over the value graph, not a Jolt-specific relation language. Closed relation enums live at the @@ -958,14 +1087,13 @@ The audit surface contracts as we move through the slices: ```text post-S1: Tier A (1,265 LOC) + Tier B (638 LOC) = 1,903 LOC audited -post-S2: bolt-runtime crate + Tier B (638 LOC) = ~1,900 LOC, but - Tier A is now - versioned and reviewed - once across protocols -post-S3: bolt-runtime crate + Tier B (~500 LOC) = ~1,750 LOC -post-S4: bolt-runtime crate + Tier B (~350 LOC) = ~1,600 LOC -post-S5: bolt-runtime crate + Tier B (~290 LOC) = ~1,540 LOC -post-S6: bolt-runtime crate + Tier B (~50 LOC) = ~1,300 LOC +current: narrow runtime + Tier B (<=700 LOC) = runtime reviewed once, + Jolt math quarantined +post-S3: narrow runtime + Tier B (~500 LOC) = value graph absorbs + simpler relation math +post-S4: narrow runtime + Tier B (~350 LOC) = eval-family strings gone +post-S5: narrow runtime + Tier B (~290 LOC) = relations become plans +post-S6: narrow runtime + Tier B (~50 LOC) = optional bytecode data ``` The shape of the audit also changes: post-S5, almost all of Tier B is the @@ -988,11 +1116,12 @@ us real-data core-vs-Bolt setup/prove/verify/proof-size/RSS measurements, but their current thresholds are broad smoke limits. Treat them as necessary but not sufficient for interpreter-heavy slices. -Before S2.5, S3, or S5 lands, record a local verifier-time baseline from the +Before S2.75, S3, or S5 lands, record a local verifier-time baseline from the SHA2-chain perf oracle and rerun it after the slice. If a verifier-time change is noisy, rerun before calling it real. If a repeatable regression remains, either fix it or explicitly document why the readability/security gain is worth -the cost. Do not loosen perf thresholds to make a refactor pass. +the cost. Do not loosen perf thresholds to make a refactor pass. The existing +S2/S2.5 progress should keep its captured baselines as reference data. The expected trend is "no measurable verifier change," because the interpreter dispatches are straightforward and relation/value-graph evaluation happens a @@ -1012,6 +1141,8 @@ correctness check. The Rust emitter should become a pretty-printer for typed plans, not the place where verifier semantics are invented. Use these checks during every slice: +- If the emitter needs to classify a verifier fact, add or extend a planning + pass instead. - If emitted Rust contains a new helper function with protocol math, ask why that helper is not a typed value-graph op or relation plan row. - If the emitter parses or assembles meaning from a symbol string, add a typed @@ -1027,24 +1158,24 @@ where verifier semantics are invented. Use these checks during every slice: ## Locked sequencing decisions -The investigation pass resolved the implementation choices that should not need -more user input before an overnight run: +The investigation pass resolved the implementation choices that should guide the +next autonomous implementation slices: -1. `bolt-verifier-runtime` is a standalone workspace crate, with no - `bolt::*` re-export. -2. Runtime relation-bearing plan structs are generic over `R: - ProtocolRelation`; Jolt relation variants live in `JoltRelationKind`. -3. Stage 8 source-stage handling is local to Stage 8 until the PCS/opening +1. Keep `bolt-verifier-runtime`, but define it narrowly. It is a verifier + interpreter crate, not a generic codegen dumping ground. +2. Runtime relation-bearing plan structs remain generic over + `R: ProtocolRelation`; Jolt relation variants live in `JoltRelationKind`. +3. Add CPU-to-Rust planning passes before adding more runtime helper surface. +4. Stage 8 source-stage handling is local to Stage 8 until the PCS/opening model is made fully typed. -4. Legacy names such as `ThroughStage5` may remain as user-facing constructors, +5. Legacy names such as `ThroughStage5` may remain as user-facing constructors, but internally they resolve to `VerifierTarget { checkpoint, evaluation }`. -5. S2 does not need a perf baseline because it is import/extraction work. - S2.5, S3, and S5 do need before/after verifier-time baselines because they - add or change interpreter execution. -6. S3 starts with the value-graph foundation plus Stage 3/4 conversions. It +6. S2.75, S3, and S5 need before/after verifier-time baselines because they add + or change interpreter/planning execution. +7. S3 starts with the value-graph foundation plus Stage 3/4 conversions. It does not start with bytecode, RAM sparse evaluators, lookup-table MLEs, or univariate-skip verifier replacement. -7. S6 remains optional and should be deferred unless there is a second protocol +8. S6 remains optional and should be deferred unless there is a second protocol user or concrete audit pressure for typed bytecode-row encoding. --- @@ -1052,23 +1183,20 @@ more user input before an overnight run: ## Sequencing decision tree ```text -Land S2 first. [unconditional] - Extract Tier A to standalone bolt-verifier-runtime. - Genericize runtime relation-bearing plans over ProtocolRelation. - Move JoltRelationKind and Stage8SourceStage out of the runtime. - Re-baseline ceilings. - Delete old common path; no compatibility re-export. - -Capture verifier perf baseline. [before interpreter changes] - Run SHA2-chain 2^16; run 2^20 if overnight budget allows. - Record verify_ms/proof_bytes/RSS and keep Perfetto traces. - -Land S2.5 next. [unconditional] - Make verifier.rs execute a typed verifier program. - Stages become proof-slot labels / diagnostic scopes, not control flow. - Keep proof serialization and public artifact shape unchanged. - -Land S3 next. [unconditional] +Current stack. [already in progress] + Runtime extraction, typed relation IDs, top-level verifier program, + output-claim plans, cleanup gates. + +Do S2 boundary audit next. [unconditional] + Narrow runtime APIs. + Move polynomial helpers to jolt-poly. + Classify runtime vs Jolt verifier core vs planning-pass ownership. + +Add S2.75 planning seams next. [unconditional] + Make CPU-to-Rust verifier planning explicit. + Prevent new semantics from landing in emitters or runtime string dispatch. + +Land S3 after planning seams. [unconditional] Establish scalar/point/field-vector/eval-family value graph. Convert Stage 3 then Stage 4 relation-output checks first. Defer bytecode, RAM sparse, lookup-table, and univariate-skip special cases. From f0940678b0f9f14f3d2c66493a0ca59066b65794 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 16:00:48 -0600 Subject: [PATCH 030/171] refactor(bolt): lift stage7 output claim --- .../src/protocols/jolt/emit/rust/stage7.rs | 225 ++++++++++++------ .../bolt/src/protocols/jolt/phases/stage7.rs | 121 +++++++++- crates/bolt/tests/commitment_ir.rs | 27 ++- .../src/plan_adapters/generated_stage7.rs | 3 +- crates/jolt-verifier/src/stages/stage7.rs | 201 ++++++++++------ 5 files changed, 422 insertions(+), 155 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index d97c7c2e28..9873d4f3d1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -9,6 +9,12 @@ use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; +use super::output_claims::{ + FieldExprDependencies, StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan, + StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, + SumcheckOutputClaimAst as Stage7SumcheckOutputClaimAst, + SumcheckOutputClaimPlan as Stage7SumcheckOutputClaimPlan, +}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::schema::verify_cpu_schema; @@ -29,6 +35,8 @@ pub struct Stage7CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, + pub output_values: Vec, + pub output_claims: Vec, pub point_zeros: Vec, pub point_slices: Vec, pub point_concats: Vec, @@ -101,6 +109,16 @@ pub struct Stage7FieldExprPlan { pub operands: Vec, } +impl FieldExprDependencies for Stage7FieldExprPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn operands(&self) -> &[String] { + &self.operands + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage7SumcheckClaimPlan { pub symbol: String, @@ -253,6 +271,8 @@ impl Stage7CpuProgram { let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); + let mut output_values = Vec::new(); + let mut output_claim_asts = Vec::new(); let mut point_zeros = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); @@ -465,6 +485,32 @@ impl Stage7CpuProgram { oracle: symbol_attr(op, "oracle")?, }); } + "cpu.structured_polynomial_eval" => { + output_values.push(Stage7StructuredPolynomialEvalPlan { + symbol: string_attr(op, "sym_name")?, + polynomial: string_attr(op, "polynomial")?, + x_point: Stage7StructuredPolynomialPointPlan { + source: operand_symbol(op, 0)?, + segment: string_attr(op, "x_point_segment")?, + length: string_attr(op, "x_point_length")?, + order: string_attr(op, "x_point_order")?, + }, + y_point: Stage7StructuredPolynomialPointPlan { + source: operand_symbol(op, 1)?, + segment: string_attr(op, "y_point_segment")?, + length: string_attr(op, "y_point_length")?, + order: string_attr(op, "y_point_order")?, + }, + }); + } + "cpu.sumcheck_output_claim" => { + output_claim_asts.push(Stage7SumcheckOutputClaimAst { + relation: symbol_attr(op, "relation")?, + claim_value: operand_symbol(op, 0)?, + polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, + polynomial_eval_operands: operand_symbols(op, 1)?, + }); + } "cpu.point_zero" => { point_zeros.push(Stage7PointZeroPlan { symbol: string_attr(op, "sym_name")?, @@ -523,11 +569,31 @@ impl Stage7CpuProgram { } } + let role = module + .role() + .ok_or_else(|| EmitError::new("missing cpu party role"))?; + if role == Role::Prover { + super::output_claims::prune_output_only_field_exprs( + &mut field_exprs, + claims.iter().map(|claim| claim.claim_value.as_str()), + output_claim_asts + .iter() + .map(|claim| claim.claim_value.as_str()), + ); + } + let output_claims = if role == Role::Verifier { + super::output_claims::resolve_output_claims( + "stage7", + &output_values, + output_claim_asts, + )? + } else { + Vec::new() + }; + Ok(Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, - role: module - .role() - .ok_or_else(|| EmitError::new("missing cpu party role"))?, + role, steps, transcript_squeezes, transcript_absorb_bytes, @@ -540,6 +606,8 @@ impl Stage7CpuProgram { drivers, instance_results, evals, + output_values, + output_claims, point_zeros, point_slices, point_concats, @@ -563,6 +631,9 @@ impl Stage7CpuProgram { } Role::Verifier => self.verify_verifier_driver_bindings()?, } + if self.role == Role::Verifier { + self.verify_output_claims()?; + } self.verify_opening_flow() } @@ -640,6 +711,26 @@ impl Stage7CpuProgram { )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); + values.extend(symbols( + self.output_values.iter().map(|value| &value.symbol), + )); + values + } + + fn point_value_symbols(&self) -> BTreeSet { + let mut values = symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + ); + values.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + values.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); + values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + values.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); values } @@ -816,6 +907,24 @@ impl Stage7CpuProgram { Ok(()) } + fn verify_output_claims(&self) -> Result<(), EmitError> { + let relations = symbols( + self.instance_results + .iter() + .map(|instance| &instance.relation), + ); + let field_values = self.field_value_symbols(); + let point_values = self.point_value_symbols(); + super::output_claims::verify_output_claims( + "stage7", + &self.output_values, + &self.output_claims, + &relations, + &field_values, + &point_values, + ) + } + fn verify_opening_flow(&self) -> Result<(), EmitError> { let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); point_sources.extend(symbols( @@ -984,9 +1093,8 @@ impl Stage7CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ - use jolt_field::{Field, Fr, RingCore};\n\ - use jolt_poly::EqPolynomial;\n\ + "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ + use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" } @@ -1215,6 +1323,8 @@ pub type Stage7CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage7SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage7SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage7SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage7StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage7RelationKind; pub use bolt_verifier_runtime::{ @@ -1231,6 +1341,11 @@ pub use bolt_verifier_runtime::{ StageParams as Stage7Params, SumcheckBatchPlan as Stage7SumcheckBatchPlan, SumcheckEvalPlan as Stage7SumcheckEvalPlan, + StructuredPolynomialKind as Stage7StructuredPolynomialKind, + StructuredPolynomialPointLength as Stage7StructuredPolynomialPointLength, + StructuredPolynomialPointOrder as Stage7StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment as Stage7StructuredPolynomialPointSegment, TranscriptAbsorbBytesPlan as Stage7TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage7TranscriptSqueezeKind, TranscriptSqueezePlan as Stage7TranscriptSqueezePlan, @@ -1270,9 +1385,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); source.push_str(&self.emit_sumcheck_claim_constants()?); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_sumcheck_driver_constants()?); + if self.role == Role::Verifier { + source.push_str(&self.emit_verifier_output_claim_constants()?); + } source.push_str(&self.emit_tail_constants()?); let output_claims_field = if self.role == Role::Verifier { - " output_claims: &[],\n" + " output_claims: STAGE7_SUMCHECK_OUTPUT_CLAIMS,\n" } else { "" }; @@ -1788,6 +1906,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); ) } + fn emit_verifier_output_claim_constants(&self) -> Result { + super::output_claims::emit_verifier_output_claim_constants( + "Stage7", + &self.role, + &self.output_claims, + ) + } + fn emit_point_zero_constants(&self) -> String { let zeros = self .point_zeros @@ -2264,7 +2390,21 @@ fn expected_batched_output_claim( }; let value = match relation { Stage7RelationKind::Stage7HammingWeightClaimReduction => { - expected_hamming_weight_claim_reduction(program, driver, store, evals, local_point)? + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage7Error::UnsupportedRelation { + relation: instance.relation, + })?; + bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )? } relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }), }; @@ -2272,75 +2412,6 @@ fn expected_batched_output_claim( } Ok(expected) } - -fn expected_hamming_weight_claim_reduction( - program: &'static Stage7VerifierProgramPlan, - driver: &'static Stage7SumcheckDriverPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage7NamedEval], - local_point: &[Fr], -) -> Result { - let rho_rev = reverse_slice(local_point); - let booleanity_point = bolt_verifier_runtime::store_point(store, "stage7.input.stage6.booleanity.InstructionRa_0")?; - let r_addr_bool = - booleanity_point - .get(..local_point.len()) - .ok_or(VerifyStage7Error::InvalidInputLength { - input: "stage7.input.stage6.booleanity.InstructionRa_0", - expected: local_point.len(), - actual: booleanity_point.len(), - })?; - let eq_bool = EqPolynomial::::mle(&rho_rev, r_addr_bool); - let gamma = bolt_verifier_runtime::store_scalar(store, "stage7.hamming_weight_claim_reduction.gamma")?; - let mut gamma_power = Fr::from_u64(1); - let mut expected = Fr::from_u64(0); - let mut eval_plans = program - .evals - .iter() - .filter(|eval| eval.source == driver.symbol) - .collect::>(); - eval_plans.sort_by_key(|eval| eval.index); - for eval_plan in eval_plans { - let g_i = eval_by_name(evals, eval_plan.name)?; - let virt_point = - stage7_virtualization_point(store, eval_plan.oracle, local_point.len())?; - let eq_virt = EqPolynomial::::mle(&rho_rev, virt_point); - expected += g_i * (gamma_power + gamma_power * gamma * eq_bool - + gamma_power * gamma.square() * eq_virt); - gamma_power *= gamma; - gamma_power *= gamma; - gamma_power *= gamma; - } - Ok(expected) -} - -fn stage7_virtualization_point<'a>( - store: &'a bolt_verifier_runtime::ValueStore, - oracle: &str, - log_k_chunk: usize, -) -> Result<&'a [Fr], VerifyStage7Error> { - let symbol = if oracle.starts_with("InstructionRa_") { - format!("stage7.input.stage6.instruction_ra_virtual.{oracle}") - } else if oracle.starts_with("BytecodeRa_") { - format!("stage7.input.stage6.bytecode_read_raf.{oracle}") - } else if oracle.starts_with("RamRa_") { - format!("stage7.input.stage6.ram_ra_virtual.{oracle}") - } else { - return Err(VerifyStage7Error::MissingValue { - symbol: "stage7.hamming_weight_claim_reduction.oracle", - }); - }; - let point = store.try_point(&symbol).ok_or(VerifyStage7Error::MissingValue { - symbol: "stage7.hamming_weight_claim_reduction.virtualization_point", - })?; - point - .get(..log_k_chunk) - .ok_or(VerifyStage7Error::InvalidInputLength { - input: "stage7.hamming_weight_claim_reduction.virtualization_point", - expected: log_k_chunk, - actual: point.len(), - }) -} "# } } diff --git a/crates/bolt/src/protocols/jolt/phases/stage7.rs b/crates/bolt/src/protocols/jolt/phases/stage7.rs index c37568c3d3..b1df8b3bd7 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage7.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage7.rs @@ -8,6 +8,10 @@ use crate::schema::{verify_protocol_schema, SchemaError}; use super::super::oracles; use super::super::params::JoltProtocolParams; use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type}; +use super::sumcheck_output::{ + append_structured_polynomial_eval, append_sumcheck_output_claim, OutputClaimSpec, + StructuredPolynomialPointSpec, StructuredPolynomialSpec, +}; const HAMMING_WEIGHT_CLAIM_REDUCTION_DEGREE: usize = 2; @@ -450,7 +454,7 @@ fn append_stage7_sumcheck<'c, 'a>( point, result_value, )?; - append_stage7_output_openings(context, module, params, spec.openings, instance)?; + append_stage7_output_openings(context, module, params, spec.openings, spec.gamma, instance)?; Ok(state) } @@ -532,6 +536,7 @@ fn append_stage7_output_openings<'c, 'a>( module: &'a BoltModule<'c, Protocol>, params: &JoltProtocolParams, inputs: &Stage7OpeningInputs<'c, 'a>, + gamma: Value<'c, 'a>, instance: (Value<'c, 'a>, Value<'c, 'a>), ) -> Result<(), MlirError> { let cycle = append_point_slice( @@ -554,6 +559,7 @@ fn append_stage7_output_openings<'c, 'a>( let mut claims = Vec::with_capacity(inputs.ra_inputs.len()); let mut claim_symbols = Vec::with_capacity(inputs.ra_inputs.len()); + let mut output_evals = Vec::with_capacity(inputs.ra_inputs.len()); for (index, input) in inputs.ra_inputs.iter().enumerate() { let eval = append_sumcheck_eval( context, @@ -567,6 +573,7 @@ fn append_stage7_output_openings<'c, 'a>( index, instance.1, )?; + output_evals.push(eval); let symbol = format!( "stage7.hamming_weight_claim_reduction.opening.{}", input.oracle @@ -586,6 +593,7 @@ fn append_stage7_output_openings<'c, 'a>( }, )?); } + append_stage7_output_claim(context, module, inputs, instance.0, gamma, &output_evals)?; let claim_names = claim_symbols.iter().map(String::as_str).collect::>(); let _batch = context.append_typed_op( module, @@ -604,6 +612,117 @@ fn append_stage7_output_openings<'c, 'a>( Ok(()) } +fn append_stage7_output_claim<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + inputs: &Stage7OpeningInputs<'c, 'a>, + instance_point: Value<'c, 'a>, + gamma: Value<'c, 'a>, + output_evals: &[Value<'c, 'a>], +) -> Result<(), MlirError> { + let booleanity_eq_symbol = "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"; + let booleanity_eq = append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol: booleanity_eq_symbol, + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::prefix("x_point", "as_is"), + }, + instance_point, + inputs.booleanity_point, + )?; + + let mut polynomial_evals = Vec::with_capacity(output_evals.len() + 1); + polynomial_evals.push((booleanity_eq_symbol.to_owned(), booleanity_eq)); + let mut terms = Vec::with_capacity(3 * output_evals.len()); + for (index, (input, &output_eval)) in inputs.ra_inputs.iter().zip(output_evals).enumerate() { + terms.push(append_weighted_eval( + context, + module, + &format!("stage7.hamming_weight_claim_reduction.output.term.{index}.value"), + output_eval, + gamma, + 3 * index, + )?); + + let booleanity_product = append_field_mul( + context, + module, + &format!( + "stage7.hamming_weight_claim_reduction.output.term.{index}.booleanity_product" + ), + output_eval, + booleanity_eq, + )?; + terms.push(append_weighted_eval( + context, + module, + &format!("stage7.hamming_weight_claim_reduction.output.term.{index}.booleanity"), + booleanity_product, + gamma, + 3 * index + 1, + )?); + + let virtualization_eq_symbol = format!( + "stage7.hamming_weight_claim_reduction.output.eq.{}.virtualization", + input.oracle + ); + let virtualization_eq = append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol: &virtualization_eq_symbol, + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("reverse"), + y_point: StructuredPolynomialPointSpec::prefix("x_point", "as_is"), + }, + instance_point, + input.virtualization.point, + )?; + polynomial_evals.push((virtualization_eq_symbol, virtualization_eq)); + let virtualization_product = append_field_mul( + context, + module, + &format!( + "stage7.hamming_weight_claim_reduction.output.term.{index}.virtualization_product" + ), + output_eval, + virtualization_eq, + )?; + terms.push(append_weighted_eval( + context, + module, + &format!("stage7.hamming_weight_claim_reduction.output.term.{index}.virtualization"), + virtualization_product, + gamma, + 3 * index + 2, + )?); + } + let output_claim = append_field_sum( + context, + module, + "stage7.hamming_weight_claim_reduction.output.claim_expr", + &terms, + )?; + let polynomial_eval_refs = polynomial_evals + .iter() + .map(|(symbol, value)| (symbol.as_str(), *value)) + .collect::>(); + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage7.hamming_weight_claim_reduction.output", + stage: "stage7", + relation: "jolt.stage7.hamming_weight_claim_reduction", + }, + output_claim, + &polynomial_eval_refs, + ) +} + fn append_transcript_squeeze<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 2263dfaeb8..ed556f6086 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1006,6 +1006,13 @@ fn jolt_stage7_protocol_defines_hamming_weight_claim_reduction_flow() { assert!(text.contains("source_claim = @stage6.hamming_booleanity.opening.HammingWeight")); assert!(text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.point.cycle\"")); assert!(text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.point\"")); + assert!( + text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.output.eq.Booleanity\"") + ); + assert!(text.contains( + "sym_name = \"stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization\"" + )); + assert!(text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.output\"")); assert!(text.contains("@stage7.hamming_weight_claim_reduction.opening.InstructionRa_0")); assert!(text.contains("@stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0")); assert!(text.contains("@stage7.hamming_weight_claim_reduction.opening.RamRa_0")); @@ -1062,6 +1069,8 @@ fn jolt_stage7_lowers_to_compute_and_cpu_role_ir() { assert!(prover_kernel_text.contains("kernel = @jolt.cpu.stage7.batched")); assert!(prover_cpu_text.contains("kernel = @jolt.cpu.stage7.batched")); assert!(prover_cpu_text.contains("point_order = \"reverse\"")); + assert!(verifier_cpu_text.contains("\"cpu.structured_polynomial_eval\"")); + assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_claim\"")); assert!(verifier_cpu_text.contains("\"cpu.sumcheck_verify_claim\"")); assert!(!verifier_kernel_text.contains("kernel = @")); assert!(!verifier_cpu_text.contains("kernel = @")); @@ -1656,6 +1665,10 @@ fn stage7_rust_targets_extract_and_compile() { assert_eq!(prover_program.drivers.len(), 1); assert_eq!(prover_program.instance_results.len(), 1); assert_eq!(prover_program.evals.len(), total_ra); + assert_eq!(prover_program.output_values.len(), total_ra + 1); + assert!(prover_program.output_claims.is_empty()); + assert_eq!(verifier_program.output_values.len(), total_ra + 1); + assert_eq!(verifier_program.output_claims.len(), 1); assert!(prover_program.point_zeros.is_empty()); assert_eq!(prover_program.point_slices.len(), 1); assert_eq!(prover_program.point_concats.len(), 1); @@ -1701,9 +1714,21 @@ fn stage7_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("Stage7RelationKind::Stage7HammingWeightClaimReduction")); - assert!(verifier_source + assert!(!verifier_source .source .contains("expected_hamming_weight_claim_reduction")); + assert!(verifier_source + .source + .contains("Stage7SumcheckOutputClaimPlan")); + assert!(verifier_source + .source + .contains("stage7.hamming_weight_claim_reduction.output.eq.Booleanity")); + assert!(verifier_source.source.contains( + "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization" + )); + assert!(verifier_source + .source + .contains("bolt_verifier_runtime::evaluate_sumcheck_output_claim")); assert!(verifier_source .source .contains("stage7.input.stage6.booleanity.InstructionRa_0")); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs index cac54f9ba5..d88ea66e7a 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs @@ -26,5 +26,6 @@ define_stage_adapter!( Stage7OpeningClaimEqualityPlan, Stage7OpeningBatchPlan, point_zero = Stage7PointZeroPlan, - empty_output_claims = yes + output_claims = Stage7SumcheckOutputClaimPlan, + output_values = Stage7StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index c6c30c43e4..0426eaf89e 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -1,8 +1,7 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; -use jolt_field::{Field, Fr, RingCore}; -use jolt_poly::EqPolynomial; +use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; +use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -16,6 +15,8 @@ pub type Stage7CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage7SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage7SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage7SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage7StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage7RelationKind; pub use bolt_verifier_runtime::{ @@ -32,6 +33,11 @@ pub use bolt_verifier_runtime::{ StageParams as Stage7Params, SumcheckBatchPlan as Stage7SumcheckBatchPlan, SumcheckEvalPlan as Stage7SumcheckEvalPlan, + StructuredPolynomialKind as Stage7StructuredPolynomialKind, + StructuredPolynomialPointLength as Stage7StructuredPolynomialPointLength, + StructuredPolynomialPointOrder as Stage7StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment as Stage7StructuredPolynomialPointSegment, TranscriptAbsorbBytesPlan as Stage7TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage7TranscriptSqueezeKind, TranscriptSqueezePlan as Stage7TranscriptSqueezePlan, @@ -204,7 +210,60 @@ pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[ stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial88", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial87", "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial89", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial88", "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial90", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial89", "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial91", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial90", "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial92", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial91", "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial93", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial92", "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial94", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial93", "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial95", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial94", "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial96", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial95", "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial97", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial96", "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial98", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial97", "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial99", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial98", "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial100", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial99", "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial101", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial100", "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial102", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial101", "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial103", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial102", "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial104", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial103", "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial105", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial104", "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial106", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial105", "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial107", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial106", "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial108", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial107", "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial109", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial108", "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial110", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial109", "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial111", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial110", "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.booleanity.gamma_pow", Stage7FieldExprKind::Pow(1), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.0.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.0.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.virtualization.gamma_pow", Stage7FieldExprKind::Pow(2), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.0.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.0.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.value.gamma_pow", Stage7FieldExprKind::Pow(3), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.1.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.booleanity.gamma_pow", Stage7FieldExprKind::Pow(4), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.1.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.1.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.virtualization.gamma_pow", Stage7FieldExprKind::Pow(5), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.1.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.1.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.value.gamma_pow", Stage7FieldExprKind::Pow(6), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.2.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.booleanity.gamma_pow", Stage7FieldExprKind::Pow(7), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.2.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.2.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.virtualization.gamma_pow", Stage7FieldExprKind::Pow(8), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.2.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.2.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.value.gamma_pow", Stage7FieldExprKind::Pow(9), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.3.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.booleanity.gamma_pow", Stage7FieldExprKind::Pow(10), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.3.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.3.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.virtualization.gamma_pow", Stage7FieldExprKind::Pow(11), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.3.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.3.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.value.gamma_pow", Stage7FieldExprKind::Pow(12), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.4.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.booleanity.gamma_pow", Stage7FieldExprKind::Pow(13), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.4.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.4.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.virtualization.gamma_pow", Stage7FieldExprKind::Pow(14), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.4.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.4.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.value.gamma_pow", Stage7FieldExprKind::Pow(15), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.5.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.booleanity.gamma_pow", Stage7FieldExprKind::Pow(16), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.5.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.5.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.virtualization.gamma_pow", Stage7FieldExprKind::Pow(17), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.5.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.5.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.value.gamma_pow", Stage7FieldExprKind::Pow(18), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.6.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.booleanity.gamma_pow", Stage7FieldExprKind::Pow(19), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.6.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.6.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.virtualization.gamma_pow", Stage7FieldExprKind::Pow(20), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.6.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.6.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.value.gamma_pow", Stage7FieldExprKind::Pow(21), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.7.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.booleanity.gamma_pow", Stage7FieldExprKind::Pow(22), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.7.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.7.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.virtualization.gamma_pow", Stage7FieldExprKind::Pow(23), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.7.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.7.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.value.gamma_pow", Stage7FieldExprKind::Pow(24), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.8.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.booleanity.gamma_pow", Stage7FieldExprKind::Pow(25), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.8.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.8.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.virtualization.gamma_pow", Stage7FieldExprKind::Pow(26), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.8.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.8.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.value.gamma_pow", Stage7FieldExprKind::Pow(27), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.9.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.booleanity.gamma_pow", Stage7FieldExprKind::Pow(28), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.9.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.9.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.virtualization.gamma_pow", Stage7FieldExprKind::Pow(29), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.9.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.9.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.value.gamma_pow", Stage7FieldExprKind::Pow(30), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.10.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.booleanity.gamma_pow", Stage7FieldExprKind::Pow(31), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.10.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.10.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.virtualization.gamma_pow", Stage7FieldExprKind::Pow(32), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.10.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.10.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.value.gamma_pow", Stage7FieldExprKind::Pow(33), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.11.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.booleanity.gamma_pow", Stage7FieldExprKind::Pow(34), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.11.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.11.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.virtualization.gamma_pow", Stage7FieldExprKind::Pow(35), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.11.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.11.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.value.gamma_pow", Stage7FieldExprKind::Pow(36), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.12.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.booleanity.gamma_pow", Stage7FieldExprKind::Pow(37), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.12.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.12.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.virtualization.gamma_pow", Stage7FieldExprKind::Pow(38), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.12.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.12.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.value.gamma_pow", Stage7FieldExprKind::Pow(39), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.13.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.booleanity.gamma_pow", Stage7FieldExprKind::Pow(40), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.13.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.13.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.virtualization.gamma_pow", Stage7FieldExprKind::Pow(41), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.13.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.13.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.value.gamma_pow", Stage7FieldExprKind::Pow(42), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.14.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.booleanity.gamma_pow", Stage7FieldExprKind::Pow(43), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.14.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.14.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.virtualization.gamma_pow", Stage7FieldExprKind::Pow(44), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.14.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.14.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.value.gamma_pow", Stage7FieldExprKind::Pow(45), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.15.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.booleanity.gamma_pow", Stage7FieldExprKind::Pow(46), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.15.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.15.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.virtualization.gamma_pow", Stage7FieldExprKind::Pow(47), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.15.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.15.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.value.gamma_pow", Stage7FieldExprKind::Pow(48), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.16.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.booleanity.gamma_pow", Stage7FieldExprKind::Pow(49), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.16.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.16.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.virtualization.gamma_pow", Stage7FieldExprKind::Pow(50), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.16.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.16.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.value.gamma_pow", Stage7FieldExprKind::Pow(51), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.17.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.booleanity.gamma_pow", Stage7FieldExprKind::Pow(52), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.17.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.17.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.virtualization.gamma_pow", Stage7FieldExprKind::Pow(53), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.17.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.17.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.value.gamma_pow", Stage7FieldExprKind::Pow(54), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.18.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.booleanity.gamma_pow", Stage7FieldExprKind::Pow(55), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.18.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.18.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.virtualization.gamma_pow", Stage7FieldExprKind::Pow(56), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.18.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.18.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.value.gamma_pow", Stage7FieldExprKind::Pow(57), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.19.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.booleanity.gamma_pow", Stage7FieldExprKind::Pow(58), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.19.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.19.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.virtualization.gamma_pow", Stage7FieldExprKind::Pow(59), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.19.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.19.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.value.gamma_pow", Stage7FieldExprKind::Pow(60), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.20.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.booleanity.gamma_pow", Stage7FieldExprKind::Pow(61), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.20.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.20.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.virtualization.gamma_pow", Stage7FieldExprKind::Pow(62), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.20.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.20.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.value.gamma_pow", Stage7FieldExprKind::Pow(63), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.21.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.booleanity.gamma_pow", Stage7FieldExprKind::Pow(64), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.21.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.21.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.virtualization.gamma_pow", Stage7FieldExprKind::Pow(65), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.21.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.21.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.value.gamma_pow", Stage7FieldExprKind::Pow(66), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.22.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.booleanity.gamma_pow", Stage7FieldExprKind::Pow(67), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.22.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.22.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.virtualization.gamma_pow", Stage7FieldExprKind::Pow(68), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.22.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.22.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.value.gamma_pow", Stage7FieldExprKind::Pow(69), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.23.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.booleanity.gamma_pow", Stage7FieldExprKind::Pow(70), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.23.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.23.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.virtualization.gamma_pow", Stage7FieldExprKind::Pow(71), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.23.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.23.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.value.gamma_pow", Stage7FieldExprKind::Pow(72), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.24.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.booleanity.gamma_pow", Stage7FieldExprKind::Pow(73), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.24.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.24.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.virtualization.gamma_pow", Stage7FieldExprKind::Pow(74), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.24.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.24.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.value.gamma_pow", Stage7FieldExprKind::Pow(75), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.25.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.booleanity.gamma_pow", Stage7FieldExprKind::Pow(76), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.25.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.25.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.virtualization.gamma_pow", Stage7FieldExprKind::Pow(77), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.25.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.25.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.value.gamma_pow", Stage7FieldExprKind::Pow(78), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.26.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.booleanity.gamma_pow", Stage7FieldExprKind::Pow(79), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.26.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.26.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.virtualization.gamma_pow", Stage7FieldExprKind::Pow(80), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.26.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.26.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.value.gamma_pow", Stage7FieldExprKind::Pow(81), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.27.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.booleanity.gamma_pow", Stage7FieldExprKind::Pow(82), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.27.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.27.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.virtualization.gamma_pow", Stage7FieldExprKind::Pow(83), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.27.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.27.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.value.gamma_pow", Stage7FieldExprKind::Pow(84), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.28.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.booleanity.gamma_pow", Stage7FieldExprKind::Pow(85), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.28.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.28.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.virtualization.gamma_pow", Stage7FieldExprKind::Pow(86), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.28.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.28.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.value.gamma_pow", Stage7FieldExprKind::Pow(87), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.29.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.booleanity.gamma_pow", Stage7FieldExprKind::Pow(88), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.29.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.29.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.virtualization.gamma_pow", Stage7FieldExprKind::Pow(89), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.29.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.29.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.value.gamma_pow", Stage7FieldExprKind::Pow(90), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.30.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.booleanity.gamma_pow", Stage7FieldExprKind::Pow(91), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.30.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.30.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.virtualization.gamma_pow", Stage7FieldExprKind::Pow(92), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.30.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.30.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.value.gamma_pow", Stage7FieldExprKind::Pow(93), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.31.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.booleanity.gamma_pow", Stage7FieldExprKind::Pow(94), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.31.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.31.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.virtualization.gamma_pow", Stage7FieldExprKind::Pow(95), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.31.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.31.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.value.gamma_pow", Stage7FieldExprKind::Pow(96), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.32.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.booleanity.gamma_pow", Stage7FieldExprKind::Pow(97), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.32.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.32.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.virtualization.gamma_pow", Stage7FieldExprKind::Pow(98), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.32.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.32.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.value.gamma_pow", Stage7FieldExprKind::Pow(99), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.33.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.booleanity.gamma_pow", Stage7FieldExprKind::Pow(100), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.33.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.33.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.virtualization.gamma_pow", Stage7FieldExprKind::Pow(101), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.33.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.33.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.value.gamma_pow", Stage7FieldExprKind::Pow(102), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.34.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.booleanity.gamma_pow", Stage7FieldExprKind::Pow(103), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.34.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.34.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.virtualization.gamma_pow", Stage7FieldExprKind::Pow(104), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.34.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.34.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.value.gamma_pow", Stage7FieldExprKind::Pow(105), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.35.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.RamRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.booleanity.gamma_pow", Stage7FieldExprKind::Pow(106), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.35.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.35.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.virtualization.gamma_pow", Stage7FieldExprKind::Pow(107), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.35.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.35.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.value.gamma_pow", Stage7FieldExprKind::Pow(108), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.36.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.RamRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.booleanity.gamma_pow", Stage7FieldExprKind::Pow(109), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.36.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.36.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.virtualization.gamma_pow", Stage7FieldExprKind::Pow(110), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.36.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.36.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.value.gamma_pow", Stage7FieldExprKind::Pow(111), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.37.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.RamRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.booleanity.gamma_pow", Stage7FieldExprKind::Pow(112), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.37.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.37.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.virtualization.gamma_pow", Stage7FieldExprKind::Pow(113), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.37.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.37.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.value.gamma_pow", Stage7FieldExprKind::Pow(114), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.38.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.RamRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.booleanity.gamma_pow", Stage7FieldExprKind::Pow(115), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.38.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.38.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.virtualization.gamma_pow", Stage7FieldExprKind::Pow(116), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.38.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.38.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial0", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.output.term.0.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial1", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial0", "stage7.hamming_weight_claim_reduction.output.term.0.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial2", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial1", "stage7.hamming_weight_claim_reduction.output.term.1.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial3", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial2", "stage7.hamming_weight_claim_reduction.output.term.1.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial4", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial3", "stage7.hamming_weight_claim_reduction.output.term.1.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial5", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial4", "stage7.hamming_weight_claim_reduction.output.term.2.value.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial6", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial5", "stage7.hamming_weight_claim_reduction.output.term.2.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial7", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial6", "stage7.hamming_weight_claim_reduction.output.term.2.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial8", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial7", "stage7.hamming_weight_claim_reduction.output.term.3.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial9", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial8", "stage7.hamming_weight_claim_reduction.output.term.3.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial10", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial9", "stage7.hamming_weight_claim_reduction.output.term.3.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial11", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial10", "stage7.hamming_weight_claim_reduction.output.term.4.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial12", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial11", "stage7.hamming_weight_claim_reduction.output.term.4.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial13", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial12", "stage7.hamming_weight_claim_reduction.output.term.4.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial14", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial13", "stage7.hamming_weight_claim_reduction.output.term.5.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial15", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial14", "stage7.hamming_weight_claim_reduction.output.term.5.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial16", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial15", "stage7.hamming_weight_claim_reduction.output.term.5.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial17", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial16", "stage7.hamming_weight_claim_reduction.output.term.6.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial18", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial17", "stage7.hamming_weight_claim_reduction.output.term.6.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial19", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial18", "stage7.hamming_weight_claim_reduction.output.term.6.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial20", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial19", "stage7.hamming_weight_claim_reduction.output.term.7.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial21", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial20", "stage7.hamming_weight_claim_reduction.output.term.7.booleanity.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial22", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial21", "stage7.hamming_weight_claim_reduction.output.term.7.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial23", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial22", "stage7.hamming_weight_claim_reduction.output.term.8.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial24", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial23", "stage7.hamming_weight_claim_reduction.output.term.8.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial25", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial24", "stage7.hamming_weight_claim_reduction.output.term.8.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial26", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial25", "stage7.hamming_weight_claim_reduction.output.term.9.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial27", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial26", "stage7.hamming_weight_claim_reduction.output.term.9.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial28", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial27", "stage7.hamming_weight_claim_reduction.output.term.9.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial29", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial28", "stage7.hamming_weight_claim_reduction.output.term.10.value.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial30", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial29", "stage7.hamming_weight_claim_reduction.output.term.10.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial31", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial30", "stage7.hamming_weight_claim_reduction.output.term.10.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial32", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial31", "stage7.hamming_weight_claim_reduction.output.term.11.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial33", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial32", "stage7.hamming_weight_claim_reduction.output.term.11.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial34", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial33", "stage7.hamming_weight_claim_reduction.output.term.11.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial35", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial34", "stage7.hamming_weight_claim_reduction.output.term.12.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial36", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial35", "stage7.hamming_weight_claim_reduction.output.term.12.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial37", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial36", "stage7.hamming_weight_claim_reduction.output.term.12.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial38", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial37", "stage7.hamming_weight_claim_reduction.output.term.13.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial39", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial38", "stage7.hamming_weight_claim_reduction.output.term.13.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial40", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial39", "stage7.hamming_weight_claim_reduction.output.term.13.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial41", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial40", "stage7.hamming_weight_claim_reduction.output.term.14.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial42", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial41", "stage7.hamming_weight_claim_reduction.output.term.14.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial43", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial42", "stage7.hamming_weight_claim_reduction.output.term.14.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial44", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial43", "stage7.hamming_weight_claim_reduction.output.term.15.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial45", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial44", "stage7.hamming_weight_claim_reduction.output.term.15.booleanity.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial46", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial45", "stage7.hamming_weight_claim_reduction.output.term.15.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial47", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial46", "stage7.hamming_weight_claim_reduction.output.term.16.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial48", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial47", "stage7.hamming_weight_claim_reduction.output.term.16.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial49", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial48", "stage7.hamming_weight_claim_reduction.output.term.16.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial50", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial49", "stage7.hamming_weight_claim_reduction.output.term.17.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial51", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial50", "stage7.hamming_weight_claim_reduction.output.term.17.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial52", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial51", "stage7.hamming_weight_claim_reduction.output.term.17.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial53", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial52", "stage7.hamming_weight_claim_reduction.output.term.18.value.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial54", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial53", "stage7.hamming_weight_claim_reduction.output.term.18.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial55", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial54", "stage7.hamming_weight_claim_reduction.output.term.18.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial56", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial55", "stage7.hamming_weight_claim_reduction.output.term.19.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial57", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial56", "stage7.hamming_weight_claim_reduction.output.term.19.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial58", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial57", "stage7.hamming_weight_claim_reduction.output.term.19.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial59", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial58", "stage7.hamming_weight_claim_reduction.output.term.20.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial60", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial59", "stage7.hamming_weight_claim_reduction.output.term.20.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial61", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial60", "stage7.hamming_weight_claim_reduction.output.term.20.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial62", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial61", "stage7.hamming_weight_claim_reduction.output.term.21.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial63", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial62", "stage7.hamming_weight_claim_reduction.output.term.21.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial64", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial63", "stage7.hamming_weight_claim_reduction.output.term.21.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial65", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial64", "stage7.hamming_weight_claim_reduction.output.term.22.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial66", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial65", "stage7.hamming_weight_claim_reduction.output.term.22.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial67", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial66", "stage7.hamming_weight_claim_reduction.output.term.22.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial68", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial67", "stage7.hamming_weight_claim_reduction.output.term.23.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial69", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial68", "stage7.hamming_weight_claim_reduction.output.term.23.booleanity.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial70", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial69", "stage7.hamming_weight_claim_reduction.output.term.23.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial71", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial70", "stage7.hamming_weight_claim_reduction.output.term.24.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial72", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial71", "stage7.hamming_weight_claim_reduction.output.term.24.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial73", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial72", "stage7.hamming_weight_claim_reduction.output.term.24.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial74", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial73", "stage7.hamming_weight_claim_reduction.output.term.25.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial75", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial74", "stage7.hamming_weight_claim_reduction.output.term.25.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial76", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial75", "stage7.hamming_weight_claim_reduction.output.term.25.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial77", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial76", "stage7.hamming_weight_claim_reduction.output.term.26.value.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial78", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial77", "stage7.hamming_weight_claim_reduction.output.term.26.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial79", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial78", "stage7.hamming_weight_claim_reduction.output.term.26.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial80", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial79", "stage7.hamming_weight_claim_reduction.output.term.27.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial81", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial80", "stage7.hamming_weight_claim_reduction.output.term.27.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial82", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial81", "stage7.hamming_weight_claim_reduction.output.term.27.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial83", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial82", "stage7.hamming_weight_claim_reduction.output.term.28.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial84", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial83", "stage7.hamming_weight_claim_reduction.output.term.28.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial85", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial84", "stage7.hamming_weight_claim_reduction.output.term.28.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial86", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial85", "stage7.hamming_weight_claim_reduction.output.term.29.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial87", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial86", "stage7.hamming_weight_claim_reduction.output.term.29.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial88", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial87", "stage7.hamming_weight_claim_reduction.output.term.29.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial89", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial88", "stage7.hamming_weight_claim_reduction.output.term.30.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial90", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial89", "stage7.hamming_weight_claim_reduction.output.term.30.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial91", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial90", "stage7.hamming_weight_claim_reduction.output.term.30.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial92", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial91", "stage7.hamming_weight_claim_reduction.output.term.31.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial93", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial92", "stage7.hamming_weight_claim_reduction.output.term.31.booleanity.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial94", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial93", "stage7.hamming_weight_claim_reduction.output.term.31.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial95", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial94", "stage7.hamming_weight_claim_reduction.output.term.32.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial96", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial95", "stage7.hamming_weight_claim_reduction.output.term.32.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial97", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial96", "stage7.hamming_weight_claim_reduction.output.term.32.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial98", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial97", "stage7.hamming_weight_claim_reduction.output.term.33.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial99", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial98", "stage7.hamming_weight_claim_reduction.output.term.33.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial100", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial99", "stage7.hamming_weight_claim_reduction.output.term.33.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial101", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial100", "stage7.hamming_weight_claim_reduction.output.term.34.value.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial102", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial101", "stage7.hamming_weight_claim_reduction.output.term.34.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial103", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial102", "stage7.hamming_weight_claim_reduction.output.term.34.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial104", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial103", "stage7.hamming_weight_claim_reduction.output.term.35.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial105", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial104", "stage7.hamming_weight_claim_reduction.output.term.35.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial106", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial105", "stage7.hamming_weight_claim_reduction.output.term.35.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial107", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial106", "stage7.hamming_weight_claim_reduction.output.term.36.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial108", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial107", "stage7.hamming_weight_claim_reduction.output.term.36.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial109", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial108", "stage7.hamming_weight_claim_reduction.output.term.36.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial110", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial109", "stage7.hamming_weight_claim_reduction.output.term.37.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial111", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial110", "stage7.hamming_weight_claim_reduction.output.term.37.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.output.term.37.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.output.term.38.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.output.term.38.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.output.term.38.virtualization.gamma_term"]), ]; pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ @@ -225,6 +284,53 @@ pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_DRIVERS: &[Stage7SumcheckDriverPlan] = &[ Stage7SumcheckDriverPlan { symbol: "stage7.sumcheck", stage: "stage7", proof_slot: "stage7.sumcheck", kernel: None, relation: Some(Stage7RelationKind::Stage7Batched), batch: "stage7.batch", policy: "jolt_core_stage7_aligned", round_schedule: STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 4, degree: 2 }, ]; +pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage7StructuredPolynomialEvalPlan] = &[ + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.booleanity.InstructionRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_1", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_2", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, + Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_3", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, +]; + +pub const STAGE7_SUMCHECK_OUTPUT_CLAIMS: &[Stage7SumcheckOutputClaimPlan] = &[ + Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage7.hamming_weight_claim_reduction.output.claim_expr.partial115" }, +]; + pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ Stage7SumcheckInstanceResultPlan { symbol: "stage7.hamming_weight_claim_reduction.instance", source: "stage7.sumcheck", claim: "stage7.hamming_weight_claim_reduction.input", relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, index: 0, point_arity: 4, num_rounds: 4, round_offset: 0, point_order: "reverse", degree: 2 }, ]; @@ -322,7 +428,7 @@ pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan { drivers: STAGE7_SUMCHECK_DRIVERS, instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS, evals: STAGE7_SUMCHECK_EVALS, - output_claims: &[], + output_claims: STAGE7_SUMCHECK_OUTPUT_CLAIMS, point_zeros: STAGE7_POINT_ZEROS, point_slices: STAGE7_POINT_SLICES, point_concats: STAGE7_POINT_CONCATS, @@ -590,7 +696,21 @@ fn expected_batched_output_claim( }; let value = match relation { Stage7RelationKind::Stage7HammingWeightClaimReduction => { - expected_hamming_weight_claim_reduction(program, driver, store, evals, local_point)? + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage7Error::UnsupportedRelation { + relation: instance.relation, + })?; + bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + store, + instance.symbol, + evals, + local_point, + )? } relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }), }; @@ -598,72 +718,3 @@ fn expected_batched_output_claim( } Ok(expected) } - -fn expected_hamming_weight_claim_reduction( - program: &'static Stage7VerifierProgramPlan, - driver: &'static Stage7SumcheckDriverPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage7NamedEval], - local_point: &[Fr], -) -> Result { - let rho_rev = reverse_slice(local_point); - let booleanity_point = bolt_verifier_runtime::store_point(store, "stage7.input.stage6.booleanity.InstructionRa_0")?; - let r_addr_bool = - booleanity_point - .get(..local_point.len()) - .ok_or(VerifyStage7Error::InvalidInputLength { - input: "stage7.input.stage6.booleanity.InstructionRa_0", - expected: local_point.len(), - actual: booleanity_point.len(), - })?; - let eq_bool = EqPolynomial::::mle(&rho_rev, r_addr_bool); - let gamma = bolt_verifier_runtime::store_scalar(store, "stage7.hamming_weight_claim_reduction.gamma")?; - let mut gamma_power = Fr::from_u64(1); - let mut expected = Fr::from_u64(0); - let mut eval_plans = program - .evals - .iter() - .filter(|eval| eval.source == driver.symbol) - .collect::>(); - eval_plans.sort_by_key(|eval| eval.index); - for eval_plan in eval_plans { - let g_i = eval_by_name(evals, eval_plan.name)?; - let virt_point = - stage7_virtualization_point(store, eval_plan.oracle, local_point.len())?; - let eq_virt = EqPolynomial::::mle(&rho_rev, virt_point); - expected += g_i * (gamma_power + gamma_power * gamma * eq_bool - + gamma_power * gamma.square() * eq_virt); - gamma_power *= gamma; - gamma_power *= gamma; - gamma_power *= gamma; - } - Ok(expected) -} - -fn stage7_virtualization_point<'a>( - store: &'a bolt_verifier_runtime::ValueStore, - oracle: &str, - log_k_chunk: usize, -) -> Result<&'a [Fr], VerifyStage7Error> { - let symbol = if oracle.starts_with("InstructionRa_") { - format!("stage7.input.stage6.instruction_ra_virtual.{oracle}") - } else if oracle.starts_with("BytecodeRa_") { - format!("stage7.input.stage6.bytecode_read_raf.{oracle}") - } else if oracle.starts_with("RamRa_") { - format!("stage7.input.stage6.ram_ra_virtual.{oracle}") - } else { - return Err(VerifyStage7Error::MissingValue { - symbol: "stage7.hamming_weight_claim_reduction.oracle", - }); - }; - let point = store.try_point(&symbol).ok_or(VerifyStage7Error::MissingValue { - symbol: "stage7.hamming_weight_claim_reduction.virtualization_point", - })?; - point - .get(..log_k_chunk) - .ok_or(VerifyStage7Error::InvalidInputLength { - input: "stage7.hamming_weight_claim_reduction.virtualization_point", - expected: log_k_chunk, - actual: point.len(), - }) -} From 952f4e31757a28a4b9faf14563d1a1f75a7cb297 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 16:05:18 -0600 Subject: [PATCH 031/171] docs(bolt): add prover refactor plan --- crates/bolt/PROVER_PROGRAM_REFACTOR_PLAN.md | 421 ++++++++++++++++++++ 1 file changed, 421 insertions(+) create mode 100644 crates/bolt/PROVER_PROGRAM_REFACTOR_PLAN.md diff --git a/crates/bolt/PROVER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/PROVER_PROGRAM_REFACTOR_PLAN.md new file mode 100644 index 0000000000..81c21ba140 --- /dev/null +++ b/crates/bolt/PROVER_PROGRAM_REFACTOR_PLAN.md @@ -0,0 +1,421 @@ +# Prover Program Refactor Plan + +This is the prover-side companion to `crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md`. +It asks which parts of the readable emitted-verifier work should also apply to +generated prover Rust, and where the prover needs a different shape. + +The short answer is: the design philosophy transfers almost completely, but the +mechanics do not transfer one-for-one. The verifier refactor is now explicitly +pass-first and runtime-second: typed planning passes should resolve semantics +before Rust emission, and runtime crates should contain only boring reusable +mechanics. The prover should mirror that philosophy, but not by copying the +verifier runtime shape. + +The prover already delegates much of its execution to `jolt-kernels`, so its +main readability problem is not hand-written helper logic in generated files. +It is large, expanded, stage-local, and partially stringly plan data. Markos' +assessment matches this: prover codegen is currently easier because it mostly +calls big kernels; verifier remains the priority because CPU-to-Rust verifier +emission still does too much semantic work. + +The desired prover architecture is therefore: + +```text +MLIR / Bolt IR owns protocol facts + | + v +prover planning passes + | + v +typed CPU / Rust-plan IR + | + v +thin generated Rust const data + | + v +efficient prover kernels and executors +``` + +The generated prover should remain an auditable declaration of what the prover +does, not a pile of reconstructed protocol logic and not an opaque call into a +black box. + +## Current observations + +The verifier refactor plan targets generated verifier stages that historically +embedded a lot of semantic checking logic. By contrast, prover stages such as +stage 5 already have the right broad shape: a static program plan plus a thin +entry point that calls a kernel executor. + +The prover-side pain is concentrated elsewhere: + +- Some generated prover stages are still very large. A recent scan put + `crates/jolt-prover/src/stages/stage6.rs` at roughly 2,525 LOC and + `crates/jolt-prover/src/stages/stage7.rs` at roughly 1,940 LOC. +- Much of the bulk appears to come from repeated opening inputs, evals, claim + rows, batch rows, and per-stage plan tables. +- Prover plan types are stage-local and kernel-owned today, for example through + `jolt_kernels::stageN::{...}`. +- Several fields still look more like serialized strings than typed execution + contracts. +- The prover has an intentionally different import boundary than the verifier: + the verifier should avoid depending on prover and kernel crates, while the + prover is expected to call `jolt-kernels`. + +This means the prover refactor should optimize for compact typed plans over +efficient kernels, not for replacing prover kernels with a generic verifier-like +interpreter. + +This also means prover work should not compete with verifier-side CPU-to-Rust +planning. The best near-term prover contribution is to avoid divergence: share +typed plan vocabulary where it is genuinely common, move polynomial helpers to +`jolt-poly`, and keep prover generated Rust from growing new stringly execution +contracts while verifier planning is being cleaned up. + +## Guiding principle + +> The prover generated Rust should be readable protocol data over efficient +> kernels. Planning passes should own semantic assembly; Rust should only +> project typed prover plans and call the execution layer. + +Concrete corollaries: + +1. **MLIR owns semantic facts.** If prover execution depends on a relation, + opening family, batching rule, transcript event, or claim dependency, that + fact should exist as typed IR before the Rust emitter sees it. +2. **Planning passes own semantic assembly.** The gap between `cpu` and emitted + Rust should be filled by explicit prover-planning passes when the current + direct emission path starts carrying semantic decisions. +3. **Generated Rust is a projection.** The emitter should not reconstruct + prover semantics by parsing symbol names, matching prefixes, or expanding + regular families into hundreds of nearly identical rows when a typed family + plan would say the same thing. +4. **Prover kernels stay hot-path aware.** Do not move prover relation logic + into a generic interpreter merely to shrink emitted Rust. Any abstraction + around prover execution must preserve the current performance model unless + benchmark data justifies a change. +5. **Typed handles beat strings.** Strings are acceptable for diagnostics and + serialization names. Execution contracts should use enums, typed symbols, + typed family IDs, or structured plan fields. +6. **Polynomial utilities come from `jolt-poly`.** If prover kernels or emitted + plans need equality, less-than, identity, Lagrange, indexed equality, or + projected-bit polynomial helpers, use or add the right primitive in + `jolt-poly` rather than duplicating it in `jolt-kernels` or generated Rust. +7. **Compactness must stay auditable.** A range or family plan is good when it + exposes structure such as "all `InstructionRa` openings." It is bad if it + hides protocol meaning behind clever emitter-only conventions. +8. **No compatibility shadows.** When replacing a string path or expanded table + with a typed plan, perform the full cutover for that surface rather than + keeping old and new forms in parallel. + +## What transfers from the verifier refactor + +### MLIR-owned semantics + +This applies fully. The same reason verifier math should not be reconstructed +inside Rust templates also applies to prover execution metadata. The prover +should receive typed plan rows that are already semantically meaningful. + +Examples: + +- relation and kernel IDs +- transcript absorb and squeeze events +- sumcheck driver schedules +- opening inputs and opening claim groups +- eval families and indexed eval addressing +- batching structure +- proof-record slots + +### Typed program plans + +This applies strongly, but the plan should be prover-shaped. A verifier program +asks how to check proof data. A prover program asks how to generate proof data +from witness-backed executors and kernels. + +The target should look more like: + +```rust +pub struct ProverProgramPlan { + pub params: ProverParams, + pub steps: &'static [ProverStepPlan], + pub transcript_events: &'static [TranscriptEventPlan], + pub sumchecks: &'static [ProverSumcheckDriverPlan], + pub opening_inputs: &'static [OpeningInputPlan], + pub opening_families: &'static [OpeningFamilyPlan], + pub opening_batches: &'static [OpeningBatchPlan], + pub kernels: &'static [KernelInvocationPlan], +} + +pub enum ProverStepPlan { + ExecuteKernel { kernel: KernelInvocationId }, + AbsorbTranscript { event: TranscriptEventId }, + SqueezeTranscript { output: ChallengeId }, + ProveSumcheck { driver: ProverSumcheckDriverId }, + EmitOpeningClaims { batch: OpeningBatchId }, +} +``` + +This is a sketch, not a locked API. The important part is that the generated +file declares a typed execution plan rather than emitting stage-shaped Rust +logic or enormous flat arrays when the protocol structure is regular. + +### Runtime extraction + +This applies only after the plan vocabulary is clearer, and not through +`bolt-verifier-runtime`. + +The verifier plan has shifted away from "create a runtime first" and toward +"create typed planning passes first." The prover should follow the same rule. +A prover runtime crate is useful only if it owns boring execution mechanics +over `jolt-kernels`; it should not become a second place to encode prover +semantics. + +The prover should either use a dedicated prover runtime crate or a shared plan +crate that contains only concepts genuinely common to prover and verifier. The +verifier runtime has verifier-specific concerns such as expected-output checks, +accept-reject behavior, and PCS verification boundaries. Those should not leak +into prover APIs. + +Candidate crate boundaries: + +- `bolt-plan-runtime`: shared typed plan primitives, IDs, value domains, family + plans, transcript event plans, and opening/batch descriptors. +- `bolt-prover-runtime`: prover-specific execution plan interpretation over + `jolt-kernels`. +- `bolt-verifier-runtime`: verifier-specific proof checking over typed verifier + plans. + +The concrete crate split should be decided only after identifying the repeated +plan structs and duplicated concepts in generated prover and verifier surfaces. +Do not create `bolt-prover-runtime` just to move code out of generated files. +First add metrics and planning seams that prove the shared surface is real. + +### Readability and LOC gates + +This applies directly, with prover-specific metrics. + +The verifier cleanup tests should inspire a prover cleanup test that tracks: + +- generated prover stage LOC +- largest static table sizes +- number of emitted stringly execution fields +- number of stage-local plan structs or duplicate aliases +- helper function count inside generated prover stages +- generated prover surface LOC versus kernel/runtime LOC + +The goal is not to minimize total workspace LOC blindly. The goal is to move +semantic bulk into typed, reusable, audited plan/runtime concepts and reduce +generated-stage noise. + +### Subjective readability review + +This applies, but the review packet should include both the generated prover +stage and the relevant kernel ABI. For the prover, semantics are intentionally +split between plan data and execution kernels. A fair readability review should +ask whether a reviewer can understand what proof work is scheduled without +reading Bolt lowering code. + +## What does not transfer directly + +### The verifier import boundary + +The verifier should not depend on `jolt-prover`, `jolt-kernels`, or `jolt-core` +implementation details. The prover has the opposite expectation: it is the +proof-producing side and should call optimized kernel executors. + +So the prover contract should not say "no `jolt-kernels`." It should say: + +- generated prover Rust may depend on prover runtime and kernel crates; +- generated prover Rust should not reconstruct kernel semantics locally; +- kernel ABI rows should be typed, grouped, and auditable. + +### Verifier output-claim checks + +Verifier-side output-claim plans check that proof data is consistent with +expected scalar values. The prover analogue is not to verify those claims, but +to declare produced claims, openings, batches, and transcript dependencies in a +typed way. + +The shared abstraction is the vocabulary of claims, openings, eval families, and +relations. The execution meaning is side-specific. + +### Generic interpretation of hot prover math + +The verifier can afford more generic interpretation because its workload is +small relative to proving. The prover cannot assume that. Any move from +specialized kernels to generic interpreters requires explicit profiling and a +clear reason beyond generated Rust readability. + +## Proposed slices + +### P0: Mirror verifier cleanup only where it is already shared + +Do this opportunistically while verifier remains the priority. + +- Move duplicated polynomial helpers in verifier runtime, `jolt_relations`, and + `jolt-kernels` toward `jolt-poly`. +- Keep prover generated Rust compatible with the typed plan vocabulary that the + verifier planning passes introduce. +- Avoid adding a prover runtime crate until repeated plan/execution mechanics + are visible and measured. + +This is the safest prover-side work while Markos is changing higher dialects and +the verifier CPU-to-Rust planning path is still moving. + +### P1: Add prover generated-surface cleanup metrics + +Add a prover-side cleanup test parallel to the verifier cleanup test. It should +initially report and gate the current generated surface without changing +execution. + +Suggested metrics: + +- per-stage generated prover LOC +- stage 6 and stage 7 static table sizes +- count of stringly plan fields that affect execution +- count of emitted helper functions in generated stages +- count of duplicated stage-local plan structs + +The purpose of P1 is visibility. It should make the prover readability problem +concrete before changing plan APIs. + +### P2: Identify and type the largest repeated plan families + +Inspect the largest generated tables in prover stages 6 and 7 and classify +which rows are regular families. + +Likely candidates: + +- `InstructionRa_*` opening groups +- lookup-table flag families +- repeated eval plans +- opening claim groups +- opening batch membership +- point slice and concat patterns + +Replace regular expanded rows with explicit family or range plans only when the +family name, bounds, and derivation are visible in generated Rust. + +### P3: Introduce typed prover plan IDs and enums + +Remove string-backed execution contracts from prover plan rows where those +strings affect behavior. Prefer closed enums, typed IDs, and typed symbols. + +This should cover fields such as: + +- kernel kind and ABI +- step kind +- claim kind +- field expression kind +- relation or source kind +- opening family kind + +When a typed path lands, delete the string path in the same slice. + +This should be implemented through prover planning data where possible, not by +teaching the Rust emitter more string-to-token mappings. + +### P4: Add prover CPU-to-Rust planning seams + +After P1-P3 identify the repeated structures, add explicit prover planning +passes between CPU IR and emitted Rust. These passes will differ from the +verifier passes because prover execution is kernel-backed and witness-backed. + +Likely passes: + +- `plan-prover-kernel-invocations`: typed kernel IDs, ABI rows, executor data + requirements, and output artifact contracts. +- `plan-prover-sumchecks`: typed driver/batch/claim/opening plans for proof + production. +- `plan-prover-opening-flow`: typed opening inputs, produced claims, opening + batches, and transcript dependencies. +- `plan-prover-families`: compact repeated opening/eval/claim rows into named + families and ranges. + +The Rust emitter should consume those plans directly rather than rediscovering +kernel/proof semantics from CPU op attrs. + +### P5: Factor common plan vocabulary + +After P2-P4 reveal the real common surface, factor shared plan primitives out of +stage-local modules. + +Good shared candidates: + +- typed symbol and ID wrappers +- transcript event plans +- opening input descriptors +- opening family descriptors +- opening batch descriptors +- field expression descriptors +- eval-family descriptors + +Do not prematurely force prover and verifier to share side-specific execution +types. Shared vocabulary is good; shared accidental abstractions are not. + +### P6: Move toward a top-level prover program + +Once per-stage plans are compact and typed, consider a top-level +`JoltProverProgramPlan` that schedules the proof-producing flow across stages. + +This should remain secondary to P2-P5. The prover has witness state, executor +state, and hot kernels that make top-level orchestration more complex than the +verifier case. A top-level plan is useful if it clarifies scheduling and proof +record layout; it is not useful if it merely wraps existing stage calls in a +new layer. + +## Non-regression contracts + +1. **Readability cannot regress.** Generated prover Rust should become easier + to audit as proof work, not merely shorter. +2. **Performance cannot silently regress.** Prover kernels are hot-path code. + Any interpreter-heavy or dispatch-heavy change needs benchmark coverage or + explicit approval. +3. **Generated LOC should trend down.** Temporary LOC growth is acceptable only + if it replaces opaque template logic with typed declarative plan data and has + a clear path to reducing generated-stage noise. +4. **Kernel semantics must stay single-sourced.** Do not duplicate kernel math + in generated Rust for readability. +5. **No compatibility shims.** Full cutover for each changed plan surface. +6. **Equivalence and proof serialization must remain stable unless explicitly + scoped.** A readability refactor should not change proof semantics or record + layout by accident. +7. **Verifier priority remains explicit.** Prover refactor slices should not + block or complicate verifier CPU-to-Rust planning unless they remove shared + duplication, especially in `jolt-poly`. + +## Implementation readiness + +The most implementation-ready path is: + +1. Reuse or add the missing `jolt-poly` helpers that both verifier and prover + need. +2. Add prover cleanup metrics. +3. Use those metrics to lock the current stage 6 and stage 7 generated-surface + baseline. +4. Classify repeated plan rows into named families. +5. Replace the largest safe repeated families with typed family plans. +6. Type the remaining string-backed execution fields through planning data, + not emitter-local token maps. + +This path is valuable even if the final top-level prover program is deferred. +It attacks the current readability problem directly while preserving the +existing prover execution model. + +## Open questions + +- Should shared plan concepts live in a neutral `bolt-plan-runtime` crate, or + should prover and verifier each own their own runtime crate until the common + surface is clearer? +- Which prover facts should become planning-pass output versus remaining kernel + ABI data? +- Which stage 6 and stage 7 expansions are purely regular families, and which + encode irregular protocol decisions that should remain explicit rows? +- What prover benchmark should become the repeatable perf baseline for these + slices? +- How much of the prover stage shape is proof-record layout that should remain + numbered, versus historical scaffolding that can become a top-level program? + +The working bias should be conservative: first make the generated prover's +existing structure visible and typed, then decide whether a broader top-level +program refactor buys enough clarity to justify its cost. From c5c78721628c13fb2f5a904678a6fd94b60859b1 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 16:34:27 -0600 Subject: [PATCH 032/171] refactor(bolt): compact stage7 output family Represent the Stage 7 hamming output claim as a typed output-family plan instead of generated scalar rows. Add IRDL/schema/lowering/runtime support, regenerate verifier artifacts, and cover the compact family path in focused Bolt tests. --- crates/bolt-verifier-runtime/src/lib.rs | 94 +++++++++ crates/bolt/irdl/compute.mlir | 23 +++ crates/bolt/irdl/cpu.mlir | 23 +++ crates/bolt/irdl/piop.mlir | 23 +++ .../protocols/jolt/emit/rust/output_claims.rs | 179 +++++++++++++++++- .../src/protocols/jolt/emit/rust/stage3.rs | 2 + .../src/protocols/jolt/emit/rust/stage4.rs | 2 + .../src/protocols/jolt/emit/rust/stage5.rs | 2 + .../src/protocols/jolt/emit/rust/stage6.rs | 2 + .../src/protocols/jolt/emit/rust/stage7.rs | 97 +++++++++- .../src/protocols/jolt/phases/commitment.rs | 25 +++ .../src/protocols/jolt/phases/lowering.rs | 25 +++ .../bolt/src/protocols/jolt/phases/stage1.rs | 25 +++ .../bolt/src/protocols/jolt/phases/stage7.rs | 81 ++++---- .../protocols/jolt/phases/sumcheck_output.rs | 69 +++++++ crates/bolt/src/schema.rs | 96 ++++++++++ crates/bolt/tests/commitment_ir.rs | 38 ++++ crates/jolt-equivalence/src/plan_adapters.rs | 46 +++++ crates/jolt-verifier/src/stages/stage3.rs | 6 +- crates/jolt-verifier/src/stages/stage4.rs | 4 +- crates/jolt-verifier/src/stages/stage5.rs | 4 +- crates/jolt-verifier/src/stages/stage6.rs | 8 +- crates/jolt-verifier/src/stages/stage7.rs | 70 ++----- 23 files changed, 827 insertions(+), 117 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 09e4b0a0d4..f9727a53e2 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -355,10 +355,34 @@ pub struct StructuredPolynomialEvalPlan { pub y_point: StructuredPolynomialPointPlan, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct SumcheckOutputEvalFamilySharedTermPlan { + pub gamma_power_offset: usize, + pub factor: &'static str, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct SumcheckOutputEvalFamilyItemTermPlan { + pub gamma_power_offset: usize, + pub factors: &'static [&'static str], +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct SumcheckOutputEvalFamilyPlan { + pub symbol: &'static str, + pub gamma: &'static str, + pub evals: &'static [&'static str], + pub power_stride: usize, + pub value_term_offsets: &'static [usize], + pub shared_terms: &'static [SumcheckOutputEvalFamilySharedTermPlan], + pub item_terms: &'static [SumcheckOutputEvalFamilyItemTermPlan], +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct SumcheckOutputClaimPlan { pub relation: R, pub polynomial_evals: &'static [StructuredPolynomialEvalPlan], + pub eval_families: &'static [SumcheckOutputEvalFamilyPlan], pub claim_value: &'static str, } @@ -1170,6 +1194,10 @@ pub fn evaluate_sumcheck_output_claim( let value = evaluate_structured_polynomial(polynomial_eval.polynomial, &x_point, y_point)?; scratch.insert(polynomial_eval.symbol, value); } + for family in plan.eval_families { + let value = evaluate_sumcheck_output_eval_family(family, store, &scratch)?; + scratch.insert(family.symbol, value); + } evaluate_available_field_exprs_with_scratch(field_exprs, store, &mut scratch)?; scratch .scalar_or(store, plan.claim_value) @@ -1178,6 +1206,72 @@ pub fn evaluate_sumcheck_output_claim( }) } +fn evaluate_sumcheck_output_eval_family( + family: &SumcheckOutputEvalFamilyPlan, + store: &ValueStore, + scratch: &ScratchScalars, +) -> Result { + let gamma = scratch + .scalar_or(store, family.gamma) + .ok_or(RuntimePlanError::MissingValue { + symbol: family.gamma, + })?; + for term in family.item_terms { + require_operand_count(family.symbol, family.evals.len(), term.factors.len())?; + } + let value_offset_powers = family + .value_term_offsets + .iter() + .map(|&offset| pow_field(gamma, offset)) + .collect::>(); + let shared_terms = family + .shared_terms + .iter() + .map(|term| (term, pow_field(gamma, term.gamma_power_offset))) + .collect::>(); + let item_terms = family + .item_terms + .iter() + .map(|term| (term, pow_field(gamma, term.gamma_power_offset))) + .collect::>(); + let gamma_stride = pow_field(gamma, family.power_stride); + let mut gamma_base = Fr::from_u64(1); + + let mut result = Fr::from_u64(0); + for (index, eval_symbol) in family.evals.iter().enumerate() { + let eval = scratch + .scalar_or(store, eval_symbol) + .ok_or(RuntimePlanError::MissingValue { + symbol: eval_symbol, + })?; + let weighted_eval = eval * gamma_base; + for offset_power in &value_offset_powers { + result += weighted_eval * *offset_power; + } + for (term, offset_power) in &shared_terms { + let factor = + scratch + .scalar_or(store, term.factor) + .ok_or(RuntimePlanError::MissingValue { + symbol: term.factor, + })?; + result += weighted_eval * factor * *offset_power; + } + for (term, offset_power) in &item_terms { + let factor_symbol = term.factors[index]; + let factor = + scratch + .scalar_or(store, factor_symbol) + .ok_or(RuntimePlanError::MissingValue { + symbol: factor_symbol, + })?; + result += weighted_eval * factor * *offset_power; + } + gamma_base *= gamma_stride; + } + Ok(result) +} + fn evaluate_structured_polynomial_point( plan: StructuredPolynomialPointPlan, raw_point: &[Fr], diff --git a/crates/bolt/irdl/compute.mlir b/crates/bolt/irdl/compute.mlir index 6989b62dc1..03ac0ab091 100644 --- a/crates/bolt/irdl/compute.mlir +++ b/crates/bolt/irdl/compute.mlir @@ -694,6 +694,29 @@ irdl.dialect @compute { irdl.operands(x_point: %point, y_point: %point) irdl.results(value: %value) } + irdl.operation @sumcheck_output_eval_family { + %value = irdl.parametric @compute::@field_value<> + %sym = irdl.any + %power_stride = irdl.any + %value_term_offsets = irdl.any + %shared_term_offsets = irdl.any + %item_term_offsets = irdl.any + %evals = irdl.any + %shared_terms = irdl.any + %item_terms = irdl.any + irdl.attributes { + "sym_name" = %sym, + "power_stride" = %power_stride, + "value_term_offsets" = %value_term_offsets, + "shared_term_offsets" = %shared_term_offsets, + "item_term_offsets" = %item_term_offsets, + "evals" = %evals, + "shared_terms" = %shared_terms, + "item_terms" = %item_terms + } + irdl.operands(gamma: %value, inputs: variadic %value) + irdl.results(value: %value) + } irdl.operation @sumcheck_output_claim { %value = irdl.parametric @compute::@field_value<> %sym = irdl.any diff --git a/crates/bolt/irdl/cpu.mlir b/crates/bolt/irdl/cpu.mlir index da03f4941f..a7ade05045 100644 --- a/crates/bolt/irdl/cpu.mlir +++ b/crates/bolt/irdl/cpu.mlir @@ -624,6 +624,29 @@ irdl.dialect @cpu { irdl.operands(x_point: %point, y_point: %point) irdl.results(value: %value) } + irdl.operation @sumcheck_output_eval_family { + %value = irdl.parametric @cpu::@field_value<> + %sym = irdl.any + %power_stride = irdl.any + %value_term_offsets = irdl.any + %shared_term_offsets = irdl.any + %item_term_offsets = irdl.any + %evals = irdl.any + %shared_terms = irdl.any + %item_terms = irdl.any + irdl.attributes { + "sym_name" = %sym, + "power_stride" = %power_stride, + "value_term_offsets" = %value_term_offsets, + "shared_term_offsets" = %shared_term_offsets, + "item_term_offsets" = %item_term_offsets, + "evals" = %evals, + "shared_terms" = %shared_terms, + "item_terms" = %item_terms + } + irdl.operands(gamma: %value, inputs: variadic %value) + irdl.results(value: %value) + } irdl.operation @sumcheck_output_claim { %value = irdl.parametric @cpu::@field_value<> %sym = irdl.any diff --git a/crates/bolt/irdl/piop.mlir b/crates/bolt/irdl/piop.mlir index 93f3ff1069..1253f1a405 100644 --- a/crates/bolt/irdl/piop.mlir +++ b/crates/bolt/irdl/piop.mlir @@ -242,6 +242,29 @@ irdl.dialect @piop { irdl.operands(x_point: %point, y_point: %point) irdl.results(value: %value) } + irdl.operation @sumcheck_output_eval_family { + %value = irdl.parametric @field::@scalar<> + %sym = irdl.any + %power_stride = irdl.any + %value_term_offsets = irdl.any + %shared_term_offsets = irdl.any + %item_term_offsets = irdl.any + %evals = irdl.any + %shared_terms = irdl.any + %item_terms = irdl.any + irdl.attributes { + "sym_name" = %sym, + "power_stride" = %power_stride, + "value_term_offsets" = %value_term_offsets, + "shared_term_offsets" = %shared_term_offsets, + "item_term_offsets" = %item_term_offsets, + "evals" = %evals, + "shared_terms" = %shared_terms, + "item_terms" = %item_terms + } + irdl.operands(gamma: %value, inputs: variadic %value) + irdl.results(value: %value) + } irdl.operation @sumcheck_output_claim { %value = irdl.parametric @field::@scalar<> %sym = irdl.any diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index be8572da50..5e60530d35 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -19,10 +19,34 @@ pub struct StructuredPolynomialEvalPlan { pub y_point: StructuredPolynomialPointPlan, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputEvalFamilySharedTermPlan { + pub gamma_power_offset: usize, + pub factor: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputEvalFamilyItemTermPlan { + pub gamma_power_offset: usize, + pub factors: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputEvalFamilyPlan { + pub symbol: String, + pub gamma: String, + pub evals: Vec, + pub power_stride: usize, + pub value_term_offsets: Vec, + pub shared_terms: Vec, + pub item_terms: Vec, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct SumcheckOutputClaimPlan { pub relation: String, pub polynomial_evals: Vec, + pub eval_families: Vec, pub claim_value: String, } @@ -42,12 +66,17 @@ pub trait FieldExprDependencies { pub fn resolve_output_claims( stage: &str, output_values: &[StructuredPolynomialEvalPlan], + output_families: &[SumcheckOutputEvalFamilyPlan], claim_asts: Vec, ) -> Result, EmitError> { let output_values_by_symbol: BTreeMap<_, _> = output_values .iter() .map(|value| (value.symbol.as_str(), value)) .collect(); + let output_families_by_symbol: BTreeMap<_, _> = output_families + .iter() + .map(|family| (family.symbol.as_str(), family)) + .collect(); claim_asts .into_iter() .map(|claim| { @@ -79,9 +108,14 @@ pub fn resolve_output_claims( }) }) .collect::, EmitError>>()?; + let eval_families = output_families_by_symbol + .get(claim.claim_value.as_str()) + .map(|family| vec![(*family).clone()]) + .unwrap_or_default(); Ok(SumcheckOutputClaimPlan { relation: claim.relation, polynomial_evals, + eval_families, claim_value: claim.claim_value, }) }) @@ -112,6 +146,7 @@ pub fn prune_output_only_field_exprs<'a, 'b, T>( pub fn verify_output_claims( stage: &str, output_values: &[StructuredPolynomialEvalPlan], + output_families: &[SumcheckOutputEvalFamilyPlan], output_claims: &[SumcheckOutputClaimPlan], relations: &BTreeSet, field_values: &BTreeSet, @@ -142,6 +177,46 @@ pub fn verify_output_claims( verify_structured_polynomial_point_plan(stage, polynomial_eval, &polynomial_eval.x_point)?; verify_structured_polynomial_point_plan(stage, polynomial_eval, &polynomial_eval.y_point)?; } + for family in output_families { + if !field_values.contains(&family.gamma) { + return Err(EmitError::new(format!( + "{stage} output eval family @{} references missing gamma @{}", + family.symbol, family.gamma + ))); + } + for eval in &family.evals { + if !field_values.contains(eval) { + return Err(EmitError::new(format!( + "{stage} output eval family @{} references missing eval @{}", + family.symbol, eval + ))); + } + } + for term in &family.shared_terms { + if !field_values.contains(&term.factor) { + return Err(EmitError::new(format!( + "{stage} output eval family @{} references missing shared factor @{}", + family.symbol, term.factor + ))); + } + } + for term in &family.item_terms { + verify_count( + "output eval family item factors", + &family.symbol, + family.evals.len(), + term.factors.len(), + )?; + for factor in &term.factors { + if !field_values.contains(factor) { + return Err(EmitError::new(format!( + "{stage} output eval family @{} references missing item factor @{}", + family.symbol, factor + ))); + } + } + } + } for claim in output_claims { if !relations.contains(&claim.relation) { return Err(EmitError::new(format!( @@ -191,8 +266,9 @@ pub fn emit_verifier_output_claim_constants( "pub const {values_name}: &[{stage_type}StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" ), ); + let eval_families = emit_eval_family_constants(&mut source, stage_type, index, claim); claims.push(format!( - " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, claim_value: {} }},", + " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, claim_value: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, rust_str(&claim.claim_value) )); @@ -208,6 +284,91 @@ pub fn emit_verifier_output_claim_constants( Ok(source) } +fn emit_eval_family_constants( + source: &mut String, + stage_type: &str, + claim_index: usize, + claim: &SumcheckOutputClaimPlan, +) -> String { + if claim.eval_families.is_empty() { + return "&[]".to_owned(); + } + let upper_stage = stage_type.to_ascii_uppercase(); + let mut family_rows = Vec::new(); + for (family_index, family) in claim.eval_families.iter().enumerate() { + let prefix = + format!("{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_FAMILY_{family_index}"); + let evals_name = format!("{prefix}_EVALS"); + let evals = rust_str_array(&family.evals); + push_format( + source, + format_args!("pub const {evals_name}: &[&str] = &[{evals}];\n"), + ); + let value_offsets_name = format!("{prefix}_VALUE_TERM_OFFSETS"); + let value_offsets = usize_array(&family.value_term_offsets); + push_format( + source, + format_args!("pub const {value_offsets_name}: &[usize] = &[{value_offsets}];\n"), + ); + let shared_terms_name = format!("{prefix}_SHARED_TERMS"); + let shared_terms = family + .shared_terms + .iter() + .map(|term| { + format!( + " bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan {{ gamma_power_offset: {}, factor: {} }},", + term.gamma_power_offset, + rust_str(&term.factor) + ) + }) + .collect::>() + .join("\n"); + push_format( + source, + format_args!( + "pub const {shared_terms_name}: &[bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan] = &[\n{shared_terms}\n];\n" + ), + ); + + let mut item_rows = Vec::new(); + for (term_index, term) in family.item_terms.iter().enumerate() { + let factors_name = format!("{prefix}_ITEM_TERM_{term_index}_FACTORS"); + let factors = rust_str_array(&term.factors); + push_format( + source, + format_args!("pub const {factors_name}: &[&str] = &[{factors}];\n"), + ); + item_rows.push(format!( + " bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan {{ gamma_power_offset: {}, factors: {factors_name} }},", + term.gamma_power_offset + )); + } + let item_terms_name = format!("{prefix}_ITEM_TERMS"); + let item_terms = item_rows.join("\n"); + push_format( + source, + format_args!( + "pub const {item_terms_name}: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan] = &[\n{item_terms}\n];\n" + ), + ); + family_rows.push(format!( + " bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan {{ symbol: {}, gamma: {}, evals: {evals_name}, power_stride: {}, value_term_offsets: {value_offsets_name}, shared_terms: {shared_terms_name}, item_terms: {item_terms_name} }},", + rust_str(&family.symbol), + rust_str(&family.gamma), + family.power_stride + )); + } + let families_name = format!("{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_FAMILIES"); + let families = family_rows.join("\n"); + push_format( + source, + format_args!( + "pub const {families_name}: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan] = &[\n{families}\n];\n\n" + ), + ); + families_name +} + fn field_expr_dependency_closure<'a, T>( field_exprs_by_symbol: &BTreeMap<&str, &T>, roots: impl Iterator, @@ -358,3 +519,19 @@ fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Res fn rust_str(value: &str) -> String { format!("{value:?}") } + +fn rust_str_array(values: &[String]) -> String { + values + .iter() + .map(|value| rust_str(value)) + .collect::>() + .join(", ") +} + +fn usize_array(values: &[usize]) -> String { + values + .iter() + .map(ToString::to_string) + .collect::>() + .join(", ") +} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 1eedde23e6..325c41ec6f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -558,6 +558,7 @@ impl Stage3CpuProgram { super::output_claims::resolve_output_claims( "stage3", &output_values, + &[], output_claim_asts, )? } else { @@ -878,6 +879,7 @@ impl Stage3CpuProgram { super::output_claims::verify_output_claims( "stage3", &self.output_values, + &[], &self.output_claims, &relations, &field_values, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 9deafca702..19b9783e08 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -569,6 +569,7 @@ impl Stage4CpuProgram { super::output_claims::resolve_output_claims( "stage4", &output_values, + &[], output_claim_asts, )? } else { @@ -899,6 +900,7 @@ impl Stage4CpuProgram { super::output_claims::verify_output_claims( "stage4", &self.output_values, + &[], &self.output_claims, &relations, &field_values, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 756f8590bf..8a35b9521b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -569,6 +569,7 @@ impl Stage5CpuProgram { super::output_claims::resolve_output_claims( "stage5", &output_values, + &[], output_claim_asts, )? } else { @@ -900,6 +901,7 @@ impl Stage5CpuProgram { super::output_claims::verify_output_claims( "stage5", &self.output_values, + &[], &self.output_claims, &relations, &field_values, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 398ef088f1..fdd688079a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -585,6 +585,7 @@ impl Stage6CpuProgram { super::output_claims::resolve_output_claims( "stage6", &output_values, + &[], output_claim_asts, )? } else { @@ -921,6 +922,7 @@ impl Stage6CpuProgram { super::output_claims::verify_output_claims( "stage6", &self.output_values, + &[], &self.output_claims, &relations, &field_values, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 9873d4f3d1..86f54507c9 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -14,6 +14,9 @@ use super::output_claims::{ StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage7SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage7SumcheckOutputClaimPlan, + SumcheckOutputEvalFamilyItemTermPlan as Stage7SumcheckOutputEvalFamilyItemTermPlan, + SumcheckOutputEvalFamilyPlan as Stage7SumcheckOutputEvalFamilyPlan, + SumcheckOutputEvalFamilySharedTermPlan as Stage7SumcheckOutputEvalFamilySharedTermPlan, }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; @@ -36,6 +39,7 @@ pub struct Stage7CpuProgram { pub instance_results: Vec, pub evals: Vec, pub output_values: Vec, + pub output_families: Vec, pub output_claims: Vec, pub point_zeros: Vec, pub point_slices: Vec, @@ -272,6 +276,7 @@ impl Stage7CpuProgram { let mut instance_results = Vec::new(); let mut evals = Vec::new(); let mut output_values = Vec::new(); + let mut output_families = Vec::new(); let mut output_claim_asts = Vec::new(); let mut point_zeros = Vec::new(); let mut point_slices = Vec::new(); @@ -503,6 +508,9 @@ impl Stage7CpuProgram { }, }); } + "cpu.sumcheck_output_eval_family" => { + output_families.push(output_eval_family_plan(op)?); + } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage7SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, @@ -585,6 +593,7 @@ impl Stage7CpuProgram { super::output_claims::resolve_output_claims( "stage7", &output_values, + &output_families, output_claim_asts, )? } else { @@ -607,6 +616,7 @@ impl Stage7CpuProgram { instance_results, evals, output_values, + output_families, output_claims, point_zeros, point_slices, @@ -714,6 +724,9 @@ impl Stage7CpuProgram { values.extend(symbols( self.output_values.iter().map(|value| &value.symbol), )); + values.extend(symbols( + self.output_families.iter().map(|family| &family.symbol), + )); values } @@ -918,6 +931,7 @@ impl Stage7CpuProgram { super::output_claims::verify_output_claims( "stage7", &self.output_values, + &self.output_families, &self.output_claims, &relations, &field_values, @@ -2509,6 +2523,79 @@ fn symbols<'a>(values: impl Iterator) -> BTreeSet { values.cloned().collect() } +fn output_eval_family_plan( + operation: OperationRef<'_, '_>, +) -> Result { + let symbol = string_attr(operation, "sym_name")?; + let evals = symbol_array_attr(operation, "evals")?; + let shared_factors = symbol_array_attr(operation, "shared_terms")?; + let item_factors = symbol_array_attr(operation, "item_terms")?; + let value_term_offsets = int_array_attr(operation, "value_term_offsets")?; + let shared_term_offsets = int_array_attr(operation, "shared_term_offsets")?; + let item_term_offsets = int_array_attr(operation, "item_term_offsets")?; + verify_count( + "output eval family shared terms", + &symbol, + shared_term_offsets.len(), + shared_factors.len(), + )?; + verify_count( + "output eval family item term factors", + &symbol, + item_term_offsets.len() * evals.len(), + item_factors.len(), + )?; + let gamma = operand_symbol(operation, 0)?; + let eval_operands = operand_symbols_range(operation, 1, 1 + evals.len())?; + if evals != eval_operands { + return Err(EmitError::new(format!( + "stage7 output eval family @{symbol} evals do not match operands" + ))); + } + let shared_start = 1 + evals.len(); + let shared_end = shared_start + shared_factors.len(); + let shared_operands = operand_symbols_range(operation, shared_start, shared_end)?; + if shared_factors != shared_operands { + return Err(EmitError::new(format!( + "stage7 output eval family @{symbol} shared_terms do not match operands" + ))); + } + let item_operands = operand_symbols_range(operation, shared_end, operation.operand_count())?; + if item_factors != item_operands { + return Err(EmitError::new(format!( + "stage7 output eval family @{symbol} item_terms do not match operands" + ))); + } + let shared_terms = shared_term_offsets + .into_iter() + .zip(shared_factors) + .map( + |(gamma_power_offset, factor)| Stage7SumcheckOutputEvalFamilySharedTermPlan { + gamma_power_offset, + factor, + }, + ) + .collect(); + let mut item_terms = Vec::with_capacity(item_term_offsets.len()); + for (term_index, gamma_power_offset) in item_term_offsets.into_iter().enumerate() { + let start = term_index * evals.len(); + let end = start + evals.len(); + item_terms.push(Stage7SumcheckOutputEvalFamilyItemTermPlan { + gamma_power_offset, + factors: item_factors[start..end].to_vec(), + }); + } + Ok(Stage7SumcheckOutputEvalFamilyPlan { + symbol, + gamma, + evals, + power_stride: int_attr(operation, "power_stride")?, + value_term_offsets, + shared_terms, + item_terms, + }) +} + fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) @@ -2589,7 +2676,15 @@ fn operand_symbols( operation: OperationRef<'_, '_>, start_index: usize, ) -> Result, EmitError> { - (start_index..operation.operand_count()) + operand_symbols_range(operation, start_index, operation.operand_count()) +} + +fn operand_symbols_range( + operation: OperationRef<'_, '_>, + start_index: usize, + end_index: usize, +) -> Result, EmitError> { + (start_index..end_index) .map(|index| operand_symbol(operation, index)) .collect() } diff --git a/crates/bolt/src/protocols/jolt/phases/commitment.rs b/crates/bolt/src/protocols/jolt/phases/commitment.rs index cafb4f6380..c752dbaf69 100644 --- a/crates/bolt/src/protocols/jolt/phases/commitment.rs +++ b/crates/bolt/src/protocols/jolt/phases/commitment.rs @@ -947,6 +947,31 @@ pub fn lower_compute_to_cpu<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "compute.sumcheck_output_eval_family" => { + let operands = lowered_operands(op, &value_map)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs( + op, + &[ + "power_stride", + "value_term_offsets", + "shared_term_offsets", + "item_term_offsets", + "evals", + "shared_terms", + "item_terms", + ], + )?; + let operation = context.append_typed_op_with_owned_attrs( + &cpu, + "cpu.sumcheck_output_eval_family", + Some(&symbol), + &attrs, + &operands, + &["!cpu.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } "compute.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map)?; let symbol = string_attr(op, "sym_name")?; diff --git a/crates/bolt/src/protocols/jolt/phases/lowering.rs b/crates/bolt/src/protocols/jolt/phases/lowering.rs index 1c8d982b00..88fda607d4 100644 --- a/crates/bolt/src/protocols/jolt/phases/lowering.rs +++ b/crates/bolt/src/protocols/jolt/phases/lowering.rs @@ -454,6 +454,31 @@ pub(super) fn lower_party_to_compute<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "piop.sumcheck_output_eval_family" => { + let operands = lowered_operands(op, &value_map, 0)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs( + op, + &[ + "power_stride", + "value_term_offsets", + "shared_term_offsets", + "item_term_offsets", + "evals", + "shared_terms", + "item_terms", + ], + )?; + let operation = context.append_typed_op_with_owned_attrs( + &compute, + "compute.sumcheck_output_eval_family", + Some(&symbol), + &attrs, + &operands, + &["!compute.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } "piop.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; diff --git a/crates/bolt/src/protocols/jolt/phases/stage1.rs b/crates/bolt/src/protocols/jolt/phases/stage1.rs index 644fbc5bf2..54732d93f7 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage1.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage1.rs @@ -874,6 +874,31 @@ pub fn resolve_compute_kernels<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "compute.sumcheck_output_eval_family" => { + let operands = lowered_operands(op, &value_map, 0)?; + let attrs = copy_attrs( + op, + &[ + "power_stride", + "value_term_offsets", + "shared_term_offsets", + "item_term_offsets", + "evals", + "shared_terms", + "item_terms", + ], + )?; + let symbol = string_attr(op, "sym_name")?; + let operation = context.append_typed_op_with_owned_attrs( + &kernelized, + "compute.sumcheck_output_eval_family", + Some(&symbol), + &attrs, + &operands, + &["!compute.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } "compute.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?; diff --git a/crates/bolt/src/protocols/jolt/phases/stage7.rs b/crates/bolt/src/protocols/jolt/phases/stage7.rs index b1df8b3bd7..8f3b6944eb 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage7.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage7.rs @@ -9,7 +9,8 @@ use super::super::oracles; use super::super::params::JoltProtocolParams; use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type}; use super::sumcheck_output::{ - append_structured_polynomial_eval, append_sumcheck_output_claim, OutputClaimSpec, + append_structured_polynomial_eval, append_sumcheck_output_claim, + append_sumcheck_output_eval_family, OutputClaimSpec, OutputEvalFamilySpec, StructuredPolynomialPointSpec, StructuredPolynomialSpec, }; @@ -636,35 +637,9 @@ fn append_stage7_output_claim<'c, 'a>( let mut polynomial_evals = Vec::with_capacity(output_evals.len() + 1); polynomial_evals.push((booleanity_eq_symbol.to_owned(), booleanity_eq)); - let mut terms = Vec::with_capacity(3 * output_evals.len()); - for (index, (input, &output_eval)) in inputs.ra_inputs.iter().zip(output_evals).enumerate() { - terms.push(append_weighted_eval( - context, - module, - &format!("stage7.hamming_weight_claim_reduction.output.term.{index}.value"), - output_eval, - gamma, - 3 * index, - )?); - - let booleanity_product = append_field_mul( - context, - module, - &format!( - "stage7.hamming_weight_claim_reduction.output.term.{index}.booleanity_product" - ), - output_eval, - booleanity_eq, - )?; - terms.push(append_weighted_eval( - context, - module, - &format!("stage7.hamming_weight_claim_reduction.output.term.{index}.booleanity"), - booleanity_product, - gamma, - 3 * index + 1, - )?); - + let mut eval_terms = Vec::with_capacity(output_evals.len()); + let mut item_terms = Vec::with_capacity(output_evals.len()); + for (input, &output_eval) in inputs.ra_inputs.iter().zip(output_evals) { let virtualization_eq_symbol = format!( "stage7.hamming_weight_claim_reduction.output.eq.{}.virtualization", input.oracle @@ -681,30 +656,38 @@ fn append_stage7_output_claim<'c, 'a>( instance_point, input.virtualization.point, )?; - polynomial_evals.push((virtualization_eq_symbol, virtualization_eq)); - let virtualization_product = append_field_mul( - context, - module, - &format!( - "stage7.hamming_weight_claim_reduction.output.term.{index}.virtualization_product" + polynomial_evals.push((virtualization_eq_symbol.clone(), virtualization_eq)); + eval_terms.push(( + format!( + "stage7.hamming_weight_claim_reduction.eval.{}", + input.oracle ), output_eval, - virtualization_eq, - )?; - terms.push(append_weighted_eval( - context, - module, - &format!("stage7.hamming_weight_claim_reduction.output.term.{index}.virtualization"), - virtualization_product, - gamma, - 3 * index + 2, - )?); + )); + item_terms.push((virtualization_eq_symbol, virtualization_eq)); } - let output_claim = append_field_sum( + let eval_term_refs = eval_terms + .iter() + .map(|(symbol, value)| (symbol.as_str(), *value)) + .collect::>(); + let item_term_refs = item_terms + .iter() + .map(|(symbol, value)| (symbol.as_str(), *value)) + .collect::>(); + let output_claim = append_sumcheck_output_eval_family( context, module, - "stage7.hamming_weight_claim_reduction.output.claim_expr", - &terms, + OutputEvalFamilySpec { + symbol: "stage7.hamming_weight_claim_reduction.output.family", + power_stride: 3, + value_term_offsets: &[0], + shared_term_offsets: &[1], + item_term_offsets: &[2], + }, + gamma, + &eval_term_refs, + &[(booleanity_eq_symbol, booleanity_eq)], + &item_term_refs, )?; let polynomial_eval_refs = polynomial_evals .iter() diff --git a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs index fde809d924..a9a72ef4b7 100644 --- a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs +++ b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs @@ -51,6 +51,15 @@ pub(crate) struct OutputClaimSpec<'a> { pub(crate) relation: &'a str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct OutputEvalFamilySpec<'a> { + pub(crate) symbol: &'a str, + pub(crate) power_stride: usize, + pub(crate) value_term_offsets: &'a [usize], + pub(crate) shared_term_offsets: &'a [usize], + pub(crate) item_term_offsets: &'a [usize], +} + pub(crate) fn append_structured_polynomial_eval<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, @@ -107,6 +116,57 @@ pub(crate) fn append_sumcheck_output_claim<'c, 'a>( Ok(()) } +pub(crate) fn append_sumcheck_output_eval_family<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + spec: OutputEvalFamilySpec<'_>, + gamma: Value<'c, 'a>, + evals: &[(&str, Value<'c, 'a>)], + shared_terms: &[(&str, Value<'c, 'a>)], + item_terms: &[(&str, Value<'c, 'a>)], +) -> Result, MlirError> { + let mut operands = Vec::with_capacity(1 + evals.len() + shared_terms.len() + item_terms.len()); + operands.push(gamma); + operands.extend(evals.iter().map(|(_, value)| *value)); + operands.extend(shared_terms.iter().map(|(_, value)| *value)); + operands.extend(item_terms.iter().map(|(_, value)| *value)); + let eval_symbols = evals.iter().map(|(symbol, _)| *symbol).collect::>(); + let shared_symbols = shared_terms + .iter() + .map(|(symbol, _)| *symbol) + .collect::>(); + let item_symbols = item_terms + .iter() + .map(|(symbol, _)| *symbol) + .collect::>(); + let op = context.append_typed_op( + module, + "piop.sumcheck_output_eval_family", + Some(spec.symbol), + &[ + ("power_stride", &int_attr(spec.power_stride)), + ( + "value_term_offsets", + &usize_array_attr(spec.value_term_offsets), + ), + ( + "shared_term_offsets", + &usize_array_attr(spec.shared_term_offsets), + ), + ( + "item_term_offsets", + &usize_array_attr(spec.item_term_offsets), + ), + ("evals", &symbol_array_attr(&eval_symbols)), + ("shared_terms", &symbol_array_attr(&shared_symbols)), + ("item_terms", &symbol_array_attr(&item_symbols)), + ], + &operands, + &["!field.scalar"], + )?; + first_result(op, "piop.sumcheck_output_eval_family") +} + fn first_result<'c, 'a>( operation: melior::ir::operation::OperationRef<'c, 'a>, operation_name: &str, @@ -120,6 +180,15 @@ fn int_attr(value: usize) -> String { format!("{value} : i64") } +fn usize_array_attr(values: &[usize]) -> String { + let values = values + .iter() + .map(ToString::to_string) + .collect::>() + .join(", "); + format!("[{values}]") +} + fn symbol_array_attr(values: &[&str]) -> String { let values = values .iter() diff --git a/crates/bolt/src/schema.rs b/crates/bolt/src/schema.rs index 93824d21be..fb3950fdf4 100644 --- a/crates/bolt/src/schema.rs +++ b/crates/bolt/src/schema.rs @@ -25,6 +25,17 @@ const STRUCTURED_POLYNOMIAL_EVAL_ATTRS: &[&str] = &[ "y_point_order", ]; +const SUMCHECK_OUTPUT_EVAL_FAMILY_ATTRS: &[&str] = &[ + "sym_name", + "power_stride", + "value_term_offsets", + "shared_term_offsets", + "item_term_offsets", + "evals", + "shared_terms", + "item_terms", +]; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct SchemaError { message: String, @@ -378,6 +389,11 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_shape(operation, 2, 1)?; require_structured_polynomial_eval(operation) } + "piop.sumcheck_output_eval_family" => { + require_attrs(operation, SUMCHECK_OUTPUT_EVAL_FAMILY_ATTRS)?; + require_min_shape(operation, 1, 1)?; + require_sumcheck_output_eval_family(operation) + } "piop.sumcheck_output_claim" => { require_attrs( operation, @@ -735,6 +751,11 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_shape(operation, 2, 1)?; require_structured_polynomial_eval(operation) } + "compute.sumcheck_output_eval_family" => { + require_attrs(operation, SUMCHECK_OUTPUT_EVAL_FAMILY_ATTRS)?; + require_min_shape(operation, 1, 1)?; + require_sumcheck_output_eval_family(operation) + } "compute.sumcheck_output_claim" => { require_attrs( operation, @@ -1075,6 +1096,11 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_shape(operation, 2, 1)?; require_structured_polynomial_eval(operation) } + "cpu.sumcheck_output_eval_family" => { + require_attrs(operation, SUMCHECK_OUTPUT_EVAL_FAMILY_ATTRS)?; + require_min_shape(operation, 1, 1)?; + require_sumcheck_output_eval_family(operation) + } "cpu.sumcheck_output_claim" => { require_attrs( operation, @@ -1258,6 +1284,56 @@ fn require_structured_polynomial_point_attrs( Ok(()) } +fn require_sumcheck_output_eval_family(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> { + let evals = symbol_array_attr(operation, "evals")?; + let shared_terms = symbol_array_attr(operation, "shared_terms")?; + let item_terms = symbol_array_attr(operation, "item_terms")?; + let shared_offsets = int_array_attr(operation, "shared_term_offsets")?; + let item_offsets = int_array_attr(operation, "item_term_offsets")?; + if shared_terms.len() != shared_offsets.len() { + return Err(SchemaError::new(format!( + "{} attr `shared_terms` length {} does not match shared_term_offsets length {}", + operation_name(operation), + shared_terms.len(), + shared_offsets.len() + ))); + } + let expected_item_terms = item_offsets.len() * evals.len(); + if item_terms.len() != expected_item_terms { + return Err(SchemaError::new(format!( + "{} attr `item_terms` length {} does not match item_term_offsets length {} times evals length {}", + operation_name(operation), + item_terms.len(), + item_offsets.len(), + evals.len() + ))); + } + let expected_operands = 1 + evals.len() + shared_terms.len() + item_terms.len(); + if operation.operand_count() != expected_operands { + return Err(SchemaError::new(format!( + "{} expected {expected_operands} operands, got {}", + operation_name(operation), + operation.operand_count() + ))); + } + let expected_symbols = evals + .iter() + .chain(shared_terms.iter()) + .chain(item_terms.iter()) + .collect::>(); + for (index, expected) in expected_symbols.iter().enumerate() { + let operand_index = index + 1; + let actual = operand_owner_symbol(operation, operand_index)?; + if &actual != *expected { + return Err(SchemaError::new(format!( + "{} operand {operand_index} expected @{expected}, got @{actual}", + operation_name(operation) + ))); + } + } + Ok(()) +} + fn require_sumcheck_output_claim(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> { let count = int_attr(operation, "count")?; let polynomial_evals = symbol_array_attr(operation, "polynomial_evals")?; @@ -1535,6 +1611,26 @@ fn parse_symbol_array(attribute: &str) -> Option> { .collect() } +fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, SchemaError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "integer array"))?; + parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) +} + +fn parse_int_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| item.trim().parse().ok()) + .collect() +} + pub(crate) fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index ed556f6086..adfd3f41b0 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1012,6 +1012,8 @@ fn jolt_stage7_protocol_defines_hamming_weight_claim_reduction_flow() { assert!(text.contains( "sym_name = \"stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization\"" )); + assert!(text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.output.family\"")); + assert!(text.contains("\"piop.sumcheck_output_eval_family\"")); assert!(text.contains("sym_name = \"stage7.hamming_weight_claim_reduction.output\"")); assert!(text.contains("@stage7.hamming_weight_claim_reduction.opening.InstructionRa_0")); assert!(text.contains("@stage7.hamming_weight_claim_reduction.opening.BytecodeRa_0")); @@ -1070,6 +1072,7 @@ fn jolt_stage7_lowers_to_compute_and_cpu_role_ir() { assert!(prover_cpu_text.contains("kernel = @jolt.cpu.stage7.batched")); assert!(prover_cpu_text.contains("point_order = \"reverse\"")); assert!(verifier_cpu_text.contains("\"cpu.structured_polynomial_eval\"")); + assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_eval_family\"")); assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_claim\"")); assert!(verifier_cpu_text.contains("\"cpu.sumcheck_verify_claim\"")); assert!(!verifier_kernel_text.contains("kernel = @")); @@ -1668,7 +1671,33 @@ fn stage7_rust_targets_extract_and_compile() { assert_eq!(prover_program.output_values.len(), total_ra + 1); assert!(prover_program.output_claims.is_empty()); assert_eq!(verifier_program.output_values.len(), total_ra + 1); + assert_eq!(verifier_program.output_families.len(), 1); assert_eq!(verifier_program.output_claims.len(), 1); + let output_family = &verifier_program.output_families[0]; + assert_eq!( + output_family.symbol, + "stage7.hamming_weight_claim_reduction.output.family" + ); + assert_eq!( + output_family.gamma, + "stage7.hamming_weight_claim_reduction.gamma" + ); + assert_eq!(output_family.evals.len(), total_ra); + assert_eq!(output_family.power_stride, 3); + assert_eq!(output_family.value_term_offsets, vec![0]); + assert_eq!(output_family.shared_terms.len(), 1); + assert_eq!(output_family.shared_terms[0].gamma_power_offset, 1); + assert_eq!( + output_family.shared_terms[0].factor, + "stage7.hamming_weight_claim_reduction.output.eq.Booleanity" + ); + assert_eq!(output_family.item_terms.len(), 1); + assert_eq!(output_family.item_terms[0].gamma_power_offset, 2); + assert_eq!(output_family.item_terms[0].factors.len(), total_ra); + assert_eq!( + verifier_program.output_claims[0].eval_families, + vec![output_family.clone()] + ); assert!(prover_program.point_zeros.is_empty()); assert_eq!(prover_program.point_slices.len(), 1); assert_eq!(prover_program.point_concats.len(), 1); @@ -1720,12 +1749,21 @@ fn stage7_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("Stage7SumcheckOutputClaimPlan")); + assert!(verifier_source + .source + .contains("SumcheckOutputEvalFamilyPlan")); + assert!(verifier_source + .source + .contains("STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_EVALS")); assert!(verifier_source .source .contains("stage7.hamming_weight_claim_reduction.output.eq.Booleanity")); assert!(verifier_source.source.contains( "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization" )); + assert!(!verifier_source + .source + .contains("stage7.hamming_weight_claim_reduction.output.term")); assert!(verifier_source .source .contains("bolt_verifier_runtime::evaluate_sumcheck_output_claim")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 9b4b7813ae..d1ee5ee981 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -606,6 +606,52 @@ macro_rules! define_stage_adapter_impl { }) .collect(), ), + eval_families: super::leak_slice( + plan.eval_families + .iter() + .map(|family| bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { + symbol: super::leak_str(&family.symbol), + gamma: super::leak_str(&family.gamma), + evals: super::leak_slice( + family + .evals + .iter() + .map(|symbol| super::leak_str(symbol)) + .collect(), + ), + power_stride: family.power_stride, + value_term_offsets: super::leak_slice( + family.value_term_offsets.clone(), + ), + shared_terms: super::leak_slice( + family + .shared_terms + .iter() + .map(|term| bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan { + gamma_power_offset: term.gamma_power_offset, + factor: super::leak_str(&term.factor), + }) + .collect(), + ), + item_terms: super::leak_slice( + family + .item_terms + .iter() + .map(|term| bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { + gamma_power_offset: term.gamma_power_offset, + factors: super::leak_slice( + term + .factors + .iter() + .map(|symbol| super::leak_str(symbol)) + .collect(), + ), + }) + .collect(), + ), + }) + .collect(), + ), claim_value: super::leak_str(&plan.claim_value), }) .collect(), diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index d1935174eb..a8936e99fd 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -224,9 +224,9 @@ pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage3StructuredPolynomialEva ]; pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[ - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage3.spartan_shift.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage3.instruction_input.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, claim_value: "stage3.registers.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], claim_value: "stage3.spartan_shift.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], claim_value: "stage3.instruction_input.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], claim_value: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index a2faa80612..5cfdd2682a 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -183,8 +183,8 @@ pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage4StructuredPolynomialEva ]; pub const STAGE4_SUMCHECK_OUTPUT_CLAIMS: &[Stage4SumcheckOutputClaimPlan] = &[ - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage4.registers_read_write.output.claim_expr" }, - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage4.ram_val_check.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], claim_value: "stage4.registers_read_write.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], claim_value: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index e3e83e28c9..7214c636b7 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -294,8 +294,8 @@ pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage5StructuredPolynomialEva ]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIMS: &[Stage5SumcheckOutputClaimPlan] = &[ - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index d1245f3953..73995900ce 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -632,10 +632,10 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES: &[Stage6StructuredPolynomialEva ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[ - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage6.hamming_booleanity.output.claim_expr" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, claim_value: "stage6.ram_ra_virtual.output.claim_expr" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, claim_value: "stage6.instruction_ra_virtual.output.claim_expr" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, claim_value: "stage6.inc_claim_reduction.output.claim_expr" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], claim_value: "stage6.hamming_booleanity.output.claim_expr" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], claim_value: "stage6.ram_ra_virtual.output.claim_expr" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], claim_value: "stage6.instruction_ra_virtual.output.claim_expr" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: &[], claim_value: "stage6.inc_claim_reduction.output.claim_expr" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 0426eaf89e..cf0f4526fd 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -210,60 +210,7 @@ pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[ stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial88", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial87", "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial89", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial88", "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial90", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial89", "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial91", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial90", "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial92", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial91", "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial93", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial92", "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial94", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial93", "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial95", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial94", "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial96", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial95", "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial97", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial96", "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial98", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial97", "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial99", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial98", "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial100", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial99", "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial101", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial100", "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial102", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial101", "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial103", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial102", "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial104", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial103", "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial105", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial104", "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial106", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial105", "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial107", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial106", "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial108", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial107", "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial109", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial108", "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial110", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial109", "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial111", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial110", "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.booleanity.gamma_pow", Stage7FieldExprKind::Pow(1), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.0.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.0.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.virtualization.gamma_pow", Stage7FieldExprKind::Pow(2), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.0.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.0.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.0.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.value.gamma_pow", Stage7FieldExprKind::Pow(3), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.1.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.booleanity.gamma_pow", Stage7FieldExprKind::Pow(4), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.1.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.1.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.virtualization.gamma_pow", Stage7FieldExprKind::Pow(5), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.1.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.1.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.1.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.value.gamma_pow", Stage7FieldExprKind::Pow(6), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.2.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.booleanity.gamma_pow", Stage7FieldExprKind::Pow(7), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.2.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.2.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.virtualization.gamma_pow", Stage7FieldExprKind::Pow(8), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.2.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.2.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.2.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.value.gamma_pow", Stage7FieldExprKind::Pow(9), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.3.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.booleanity.gamma_pow", Stage7FieldExprKind::Pow(10), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.3.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.3.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.virtualization.gamma_pow", Stage7FieldExprKind::Pow(11), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.3.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.3.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.3.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.value.gamma_pow", Stage7FieldExprKind::Pow(12), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.4.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.booleanity.gamma_pow", Stage7FieldExprKind::Pow(13), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.4.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.4.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.virtualization.gamma_pow", Stage7FieldExprKind::Pow(14), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.4.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.4.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.4.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.value.gamma_pow", Stage7FieldExprKind::Pow(15), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.5.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.booleanity.gamma_pow", Stage7FieldExprKind::Pow(16), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.5.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.5.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.virtualization.gamma_pow", Stage7FieldExprKind::Pow(17), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.5.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.5.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.5.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.value.gamma_pow", Stage7FieldExprKind::Pow(18), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.6.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.booleanity.gamma_pow", Stage7FieldExprKind::Pow(19), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.6.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.6.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.virtualization.gamma_pow", Stage7FieldExprKind::Pow(20), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.6.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.6.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.6.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.value.gamma_pow", Stage7FieldExprKind::Pow(21), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.7.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.booleanity.gamma_pow", Stage7FieldExprKind::Pow(22), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.7.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.7.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.virtualization.gamma_pow", Stage7FieldExprKind::Pow(23), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.7.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.7.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.7.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.value.gamma_pow", Stage7FieldExprKind::Pow(24), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.8.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.booleanity.gamma_pow", Stage7FieldExprKind::Pow(25), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.8.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.8.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.virtualization.gamma_pow", Stage7FieldExprKind::Pow(26), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.8.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.8.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.8.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.value.gamma_pow", Stage7FieldExprKind::Pow(27), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.9.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.booleanity.gamma_pow", Stage7FieldExprKind::Pow(28), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.9.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.9.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.virtualization.gamma_pow", Stage7FieldExprKind::Pow(29), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.9.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.9.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.9.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.value.gamma_pow", Stage7FieldExprKind::Pow(30), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.10.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.booleanity.gamma_pow", Stage7FieldExprKind::Pow(31), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.10.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.10.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.virtualization.gamma_pow", Stage7FieldExprKind::Pow(32), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.10.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.10.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.10.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.value.gamma_pow", Stage7FieldExprKind::Pow(33), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.11.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.booleanity.gamma_pow", Stage7FieldExprKind::Pow(34), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.11.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.11.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.virtualization.gamma_pow", Stage7FieldExprKind::Pow(35), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.11.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.11.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.11.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.value.gamma_pow", Stage7FieldExprKind::Pow(36), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.12.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.booleanity.gamma_pow", Stage7FieldExprKind::Pow(37), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.12.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.12.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.virtualization.gamma_pow", Stage7FieldExprKind::Pow(38), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.12.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.12.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.12.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.value.gamma_pow", Stage7FieldExprKind::Pow(39), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.13.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.booleanity.gamma_pow", Stage7FieldExprKind::Pow(40), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.13.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.13.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.virtualization.gamma_pow", Stage7FieldExprKind::Pow(41), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.13.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.13.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.13.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.value.gamma_pow", Stage7FieldExprKind::Pow(42), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.14.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.booleanity.gamma_pow", Stage7FieldExprKind::Pow(43), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.14.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.14.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.virtualization.gamma_pow", Stage7FieldExprKind::Pow(44), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.14.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.14.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.14.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.value.gamma_pow", Stage7FieldExprKind::Pow(45), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.15.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.booleanity.gamma_pow", Stage7FieldExprKind::Pow(46), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.15.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.15.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.virtualization.gamma_pow", Stage7FieldExprKind::Pow(47), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.15.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.15.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.15.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.value.gamma_pow", Stage7FieldExprKind::Pow(48), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.16.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.booleanity.gamma_pow", Stage7FieldExprKind::Pow(49), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.16.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.16.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.virtualization.gamma_pow", Stage7FieldExprKind::Pow(50), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.16.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.16.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.16.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.value.gamma_pow", Stage7FieldExprKind::Pow(51), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.17.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.booleanity.gamma_pow", Stage7FieldExprKind::Pow(52), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.17.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.17.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.virtualization.gamma_pow", Stage7FieldExprKind::Pow(53), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.17.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.17.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.17.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.value.gamma_pow", Stage7FieldExprKind::Pow(54), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.18.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.booleanity.gamma_pow", Stage7FieldExprKind::Pow(55), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.18.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.18.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.virtualization.gamma_pow", Stage7FieldExprKind::Pow(56), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.18.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.18.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.18.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.value.gamma_pow", Stage7FieldExprKind::Pow(57), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.19.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.booleanity.gamma_pow", Stage7FieldExprKind::Pow(58), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.19.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.19.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.virtualization.gamma_pow", Stage7FieldExprKind::Pow(59), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.19.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.19.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.19.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.value.gamma_pow", Stage7FieldExprKind::Pow(60), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.20.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.booleanity.gamma_pow", Stage7FieldExprKind::Pow(61), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.20.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.20.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.virtualization.gamma_pow", Stage7FieldExprKind::Pow(62), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.20.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.20.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.20.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.value.gamma_pow", Stage7FieldExprKind::Pow(63), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.21.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.booleanity.gamma_pow", Stage7FieldExprKind::Pow(64), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.21.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.21.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.virtualization.gamma_pow", Stage7FieldExprKind::Pow(65), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.21.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.21.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.21.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.value.gamma_pow", Stage7FieldExprKind::Pow(66), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.22.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.booleanity.gamma_pow", Stage7FieldExprKind::Pow(67), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.22.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.22.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.virtualization.gamma_pow", Stage7FieldExprKind::Pow(68), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.22.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.22.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.22.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.value.gamma_pow", Stage7FieldExprKind::Pow(69), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.23.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.booleanity.gamma_pow", Stage7FieldExprKind::Pow(70), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.23.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.23.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.virtualization.gamma_pow", Stage7FieldExprKind::Pow(71), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.23.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.23.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.23.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.value.gamma_pow", Stage7FieldExprKind::Pow(72), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.24.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.booleanity.gamma_pow", Stage7FieldExprKind::Pow(73), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.24.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.24.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.virtualization.gamma_pow", Stage7FieldExprKind::Pow(74), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.24.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.24.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.24.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.value.gamma_pow", Stage7FieldExprKind::Pow(75), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.25.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.booleanity.gamma_pow", Stage7FieldExprKind::Pow(76), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.25.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.25.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.virtualization.gamma_pow", Stage7FieldExprKind::Pow(77), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.25.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.25.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.25.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.value.gamma_pow", Stage7FieldExprKind::Pow(78), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.26.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.booleanity.gamma_pow", Stage7FieldExprKind::Pow(79), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.26.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.26.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.virtualization.gamma_pow", Stage7FieldExprKind::Pow(80), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.26.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.26.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.26.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.value.gamma_pow", Stage7FieldExprKind::Pow(81), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.27.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.booleanity.gamma_pow", Stage7FieldExprKind::Pow(82), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.27.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.27.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.virtualization.gamma_pow", Stage7FieldExprKind::Pow(83), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.27.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.27.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.27.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.value.gamma_pow", Stage7FieldExprKind::Pow(84), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.28.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.booleanity.gamma_pow", Stage7FieldExprKind::Pow(85), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.28.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.28.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.virtualization.gamma_pow", Stage7FieldExprKind::Pow(86), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.28.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.28.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.28.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.value.gamma_pow", Stage7FieldExprKind::Pow(87), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.29.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.booleanity.gamma_pow", Stage7FieldExprKind::Pow(88), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.29.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.29.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.virtualization.gamma_pow", Stage7FieldExprKind::Pow(89), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.29.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.29.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.29.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.value.gamma_pow", Stage7FieldExprKind::Pow(90), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.30.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.booleanity.gamma_pow", Stage7FieldExprKind::Pow(91), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.30.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.30.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.virtualization.gamma_pow", Stage7FieldExprKind::Pow(92), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.30.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.30.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.30.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.value.gamma_pow", Stage7FieldExprKind::Pow(93), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.31.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.booleanity.gamma_pow", Stage7FieldExprKind::Pow(94), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.31.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.31.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.virtualization.gamma_pow", Stage7FieldExprKind::Pow(95), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.31.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.31.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.31.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.value.gamma_pow", Stage7FieldExprKind::Pow(96), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.32.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.booleanity.gamma_pow", Stage7FieldExprKind::Pow(97), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.32.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.32.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.virtualization.gamma_pow", Stage7FieldExprKind::Pow(98), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.32.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.32.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.32.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.value.gamma_pow", Stage7FieldExprKind::Pow(99), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.33.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.booleanity.gamma_pow", Stage7FieldExprKind::Pow(100), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.33.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.33.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.virtualization.gamma_pow", Stage7FieldExprKind::Pow(101), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.33.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.33.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.33.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.value.gamma_pow", Stage7FieldExprKind::Pow(102), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.34.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.booleanity.gamma_pow", Stage7FieldExprKind::Pow(103), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.34.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.34.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.virtualization.gamma_pow", Stage7FieldExprKind::Pow(104), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.34.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.34.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.34.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.value.gamma_pow", Stage7FieldExprKind::Pow(105), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.35.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.RamRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.booleanity.gamma_pow", Stage7FieldExprKind::Pow(106), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.35.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.35.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.virtualization.gamma_pow", Stage7FieldExprKind::Pow(107), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.35.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.35.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.35.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.value.gamma_pow", Stage7FieldExprKind::Pow(108), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.36.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.RamRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.booleanity.gamma_pow", Stage7FieldExprKind::Pow(109), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.36.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.36.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.virtualization.gamma_pow", Stage7FieldExprKind::Pow(110), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.36.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.36.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.36.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.value.gamma_pow", Stage7FieldExprKind::Pow(111), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.37.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.RamRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.booleanity.gamma_pow", Stage7FieldExprKind::Pow(112), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.37.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.37.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.virtualization.gamma_pow", Stage7FieldExprKind::Pow(113), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.37.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.37.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.37.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.value.gamma_pow", Stage7FieldExprKind::Pow(114), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.value.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.38.value.gamma_pow", "stage7.hamming_weight_claim_reduction.eval.RamRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.booleanity_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.booleanity.gamma_pow", Stage7FieldExprKind::Pow(115), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.38.booleanity.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.38.booleanity_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.virtualization_product", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.virtualization.gamma_pow", Stage7FieldExprKind::Pow(116), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.term.38.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.output.term.38.virtualization.gamma_pow", "stage7.hamming_weight_claim_reduction.output.term.38.virtualization_product"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial0", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.output.term.0.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial1", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial0", "stage7.hamming_weight_claim_reduction.output.term.0.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial2", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial1", "stage7.hamming_weight_claim_reduction.output.term.1.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial3", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial2", "stage7.hamming_weight_claim_reduction.output.term.1.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial4", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial3", "stage7.hamming_weight_claim_reduction.output.term.1.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial5", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial4", "stage7.hamming_weight_claim_reduction.output.term.2.value.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial6", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial5", "stage7.hamming_weight_claim_reduction.output.term.2.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial7", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial6", "stage7.hamming_weight_claim_reduction.output.term.2.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial8", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial7", "stage7.hamming_weight_claim_reduction.output.term.3.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial9", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial8", "stage7.hamming_weight_claim_reduction.output.term.3.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial10", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial9", "stage7.hamming_weight_claim_reduction.output.term.3.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial11", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial10", "stage7.hamming_weight_claim_reduction.output.term.4.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial12", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial11", "stage7.hamming_weight_claim_reduction.output.term.4.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial13", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial12", "stage7.hamming_weight_claim_reduction.output.term.4.virtualization.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial14", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial13", "stage7.hamming_weight_claim_reduction.output.term.5.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial15", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial14", "stage7.hamming_weight_claim_reduction.output.term.5.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial16", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial15", "stage7.hamming_weight_claim_reduction.output.term.5.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial17", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial16", "stage7.hamming_weight_claim_reduction.output.term.6.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial18", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial17", "stage7.hamming_weight_claim_reduction.output.term.6.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial19", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial18", "stage7.hamming_weight_claim_reduction.output.term.6.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial20", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial19", "stage7.hamming_weight_claim_reduction.output.term.7.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial21", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial20", "stage7.hamming_weight_claim_reduction.output.term.7.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial22", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial21", "stage7.hamming_weight_claim_reduction.output.term.7.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial23", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial22", "stage7.hamming_weight_claim_reduction.output.term.8.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial24", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial23", "stage7.hamming_weight_claim_reduction.output.term.8.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial25", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial24", "stage7.hamming_weight_claim_reduction.output.term.8.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial26", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial25", "stage7.hamming_weight_claim_reduction.output.term.9.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial27", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial26", "stage7.hamming_weight_claim_reduction.output.term.9.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial28", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial27", "stage7.hamming_weight_claim_reduction.output.term.9.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial29", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial28", "stage7.hamming_weight_claim_reduction.output.term.10.value.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial30", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial29", "stage7.hamming_weight_claim_reduction.output.term.10.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial31", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial30", "stage7.hamming_weight_claim_reduction.output.term.10.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial32", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial31", "stage7.hamming_weight_claim_reduction.output.term.11.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial33", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial32", "stage7.hamming_weight_claim_reduction.output.term.11.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial34", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial33", "stage7.hamming_weight_claim_reduction.output.term.11.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial35", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial34", "stage7.hamming_weight_claim_reduction.output.term.12.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial36", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial35", "stage7.hamming_weight_claim_reduction.output.term.12.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial37", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial36", "stage7.hamming_weight_claim_reduction.output.term.12.virtualization.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial38", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial37", "stage7.hamming_weight_claim_reduction.output.term.13.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial39", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial38", "stage7.hamming_weight_claim_reduction.output.term.13.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial40", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial39", "stage7.hamming_weight_claim_reduction.output.term.13.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial41", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial40", "stage7.hamming_weight_claim_reduction.output.term.14.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial42", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial41", "stage7.hamming_weight_claim_reduction.output.term.14.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial43", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial42", "stage7.hamming_weight_claim_reduction.output.term.14.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial44", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial43", "stage7.hamming_weight_claim_reduction.output.term.15.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial45", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial44", "stage7.hamming_weight_claim_reduction.output.term.15.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial46", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial45", "stage7.hamming_weight_claim_reduction.output.term.15.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial47", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial46", "stage7.hamming_weight_claim_reduction.output.term.16.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial48", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial47", "stage7.hamming_weight_claim_reduction.output.term.16.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial49", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial48", "stage7.hamming_weight_claim_reduction.output.term.16.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial50", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial49", "stage7.hamming_weight_claim_reduction.output.term.17.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial51", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial50", "stage7.hamming_weight_claim_reduction.output.term.17.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial52", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial51", "stage7.hamming_weight_claim_reduction.output.term.17.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial53", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial52", "stage7.hamming_weight_claim_reduction.output.term.18.value.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial54", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial53", "stage7.hamming_weight_claim_reduction.output.term.18.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial55", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial54", "stage7.hamming_weight_claim_reduction.output.term.18.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial56", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial55", "stage7.hamming_weight_claim_reduction.output.term.19.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial57", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial56", "stage7.hamming_weight_claim_reduction.output.term.19.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial58", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial57", "stage7.hamming_weight_claim_reduction.output.term.19.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial59", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial58", "stage7.hamming_weight_claim_reduction.output.term.20.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial60", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial59", "stage7.hamming_weight_claim_reduction.output.term.20.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial61", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial60", "stage7.hamming_weight_claim_reduction.output.term.20.virtualization.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial62", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial61", "stage7.hamming_weight_claim_reduction.output.term.21.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial63", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial62", "stage7.hamming_weight_claim_reduction.output.term.21.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial64", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial63", "stage7.hamming_weight_claim_reduction.output.term.21.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial65", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial64", "stage7.hamming_weight_claim_reduction.output.term.22.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial66", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial65", "stage7.hamming_weight_claim_reduction.output.term.22.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial67", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial66", "stage7.hamming_weight_claim_reduction.output.term.22.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial68", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial67", "stage7.hamming_weight_claim_reduction.output.term.23.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial69", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial68", "stage7.hamming_weight_claim_reduction.output.term.23.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial70", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial69", "stage7.hamming_weight_claim_reduction.output.term.23.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial71", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial70", "stage7.hamming_weight_claim_reduction.output.term.24.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial72", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial71", "stage7.hamming_weight_claim_reduction.output.term.24.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial73", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial72", "stage7.hamming_weight_claim_reduction.output.term.24.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial74", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial73", "stage7.hamming_weight_claim_reduction.output.term.25.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial75", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial74", "stage7.hamming_weight_claim_reduction.output.term.25.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial76", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial75", "stage7.hamming_weight_claim_reduction.output.term.25.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial77", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial76", "stage7.hamming_weight_claim_reduction.output.term.26.value.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial78", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial77", "stage7.hamming_weight_claim_reduction.output.term.26.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial79", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial78", "stage7.hamming_weight_claim_reduction.output.term.26.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial80", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial79", "stage7.hamming_weight_claim_reduction.output.term.27.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial81", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial80", "stage7.hamming_weight_claim_reduction.output.term.27.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial82", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial81", "stage7.hamming_weight_claim_reduction.output.term.27.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial83", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial82", "stage7.hamming_weight_claim_reduction.output.term.28.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial84", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial83", "stage7.hamming_weight_claim_reduction.output.term.28.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial85", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial84", "stage7.hamming_weight_claim_reduction.output.term.28.virtualization.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial86", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial85", "stage7.hamming_weight_claim_reduction.output.term.29.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial87", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial86", "stage7.hamming_weight_claim_reduction.output.term.29.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial88", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial87", "stage7.hamming_weight_claim_reduction.output.term.29.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial89", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial88", "stage7.hamming_weight_claim_reduction.output.term.30.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial90", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial89", "stage7.hamming_weight_claim_reduction.output.term.30.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial91", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial90", "stage7.hamming_weight_claim_reduction.output.term.30.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial92", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial91", "stage7.hamming_weight_claim_reduction.output.term.31.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial93", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial92", "stage7.hamming_weight_claim_reduction.output.term.31.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial94", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial93", "stage7.hamming_weight_claim_reduction.output.term.31.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial95", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial94", "stage7.hamming_weight_claim_reduction.output.term.32.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial96", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial95", "stage7.hamming_weight_claim_reduction.output.term.32.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial97", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial96", "stage7.hamming_weight_claim_reduction.output.term.32.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial98", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial97", "stage7.hamming_weight_claim_reduction.output.term.33.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial99", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial98", "stage7.hamming_weight_claim_reduction.output.term.33.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial100", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial99", "stage7.hamming_weight_claim_reduction.output.term.33.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial101", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial100", "stage7.hamming_weight_claim_reduction.output.term.34.value.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial102", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial101", "stage7.hamming_weight_claim_reduction.output.term.34.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial103", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial102", "stage7.hamming_weight_claim_reduction.output.term.34.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial104", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial103", "stage7.hamming_weight_claim_reduction.output.term.35.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial105", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial104", "stage7.hamming_weight_claim_reduction.output.term.35.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial106", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial105", "stage7.hamming_weight_claim_reduction.output.term.35.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial107", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial106", "stage7.hamming_weight_claim_reduction.output.term.36.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial108", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial107", "stage7.hamming_weight_claim_reduction.output.term.36.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial109", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial108", "stage7.hamming_weight_claim_reduction.output.term.36.virtualization.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial110", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial109", "stage7.hamming_weight_claim_reduction.output.term.37.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial111", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial110", "stage7.hamming_weight_claim_reduction.output.term.37.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.output.term.37.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.output.term.38.value.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.output.term.38.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.output.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.output.term.38.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"]), ]; pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ @@ -327,8 +274,21 @@ pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage7StructuredPolynomialEva Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_3", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, ]; +pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_EVALS: &[&str] = &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3"]; +pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_VALUE_TERM_OFFSETS: &[usize] = &[0]; +pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan { gamma_power_offset: 1, factor: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity" }, +]; +pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERM_0_FACTORS: &[&str] = &["stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]; +pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 2, factors: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERM_0_FACTORS }, +]; +pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan] = &[ + bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage7.hamming_weight_claim_reduction.output.family", gamma: "stage7.hamming_weight_claim_reduction.gamma", evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_EVALS, power_stride: 3, value_term_offsets: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_VALUE_TERM_OFFSETS, shared_terms: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_SHARED_TERMS, item_terms: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERMS }, +]; + pub const STAGE7_SUMCHECK_OUTPUT_CLAIMS: &[Stage7SumcheckOutputClaimPlan] = &[ - Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, claim_value: "stage7.hamming_weight_claim_reduction.output.claim_expr.partial115" }, + Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES, claim_value: "stage7.hamming_weight_claim_reduction.output.family" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ From 4cacad79a7884bbf837e734b9a4f9f8451d9c1ef Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 16:52:01 -0600 Subject: [PATCH 033/171] refactor(bolt): share output family extraction Move output-family parsing into shared output-claim emission support and use the compact family plan for Stage 6 inc claim reduction. Keep proof serialization and stage ABIs unchanged while reducing another scalar output formula shape. --- .../protocols/jolt/emit/rust/output_claims.rs | 181 +++++++++++++++++- .../src/protocols/jolt/emit/rust/stage6.rs | 17 +- .../src/protocols/jolt/emit/rust/stage7.rs | 90 +-------- .../bolt/src/protocols/jolt/phases/stage6.rs | 96 ++++------ crates/bolt/tests/commitment_ir.rs | 53 +++++ crates/jolt-verifier/src/stages/stage6.rs | 20 +- 6 files changed, 304 insertions(+), 153 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index 5e60530d35..cf2e84f984 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -1,7 +1,11 @@ use std::collections::{BTreeMap, BTreeSet}; +use melior::ir::operation::{OperationLike, OperationResult}; +use melior::ir::{Attribute, OperationRef}; + use crate::emit::rust::{push_format, EmitError}; -use crate::ir::Role; +use crate::ir::{string_attribute_value, Role}; +use crate::schema::operation_name; #[derive(Clone, Debug, PartialEq, Eq)] pub struct StructuredPolynomialPointPlan { @@ -58,6 +62,80 @@ pub struct SumcheckOutputClaimAst { pub claim_value: String, } +pub fn parse_output_eval_family_plan( + stage: &str, + operation: OperationRef<'_, '_>, +) -> Result { + let symbol = string_attr(operation, "sym_name")?; + let evals = symbol_array_attr(operation, "evals")?; + let shared_factors = symbol_array_attr(operation, "shared_terms")?; + let item_factors = symbol_array_attr(operation, "item_terms")?; + let value_term_offsets = int_array_attr(operation, "value_term_offsets")?; + let shared_term_offsets = int_array_attr(operation, "shared_term_offsets")?; + let item_term_offsets = int_array_attr(operation, "item_term_offsets")?; + verify_count( + "output eval family shared terms", + &symbol, + shared_term_offsets.len(), + shared_factors.len(), + )?; + verify_count( + "output eval family item term factors", + &symbol, + item_term_offsets.len() * evals.len(), + item_factors.len(), + )?; + let gamma = operand_symbol(operation, 0)?; + let eval_operands = operand_symbols(operation, 1, 1 + evals.len())?; + if evals != eval_operands { + return Err(EmitError::new(format!( + "{stage} output eval family @{symbol} evals do not match operands" + ))); + } + let shared_start = 1 + evals.len(); + let shared_end = shared_start + shared_factors.len(); + let shared_operands = operand_symbols(operation, shared_start, shared_end)?; + if shared_factors != shared_operands { + return Err(EmitError::new(format!( + "{stage} output eval family @{symbol} shared_terms do not match operands" + ))); + } + let item_operands = operand_symbols(operation, shared_end, operation.operand_count())?; + if item_factors != item_operands { + return Err(EmitError::new(format!( + "{stage} output eval family @{symbol} item_terms do not match operands" + ))); + } + let shared_terms = shared_term_offsets + .into_iter() + .zip(shared_factors) + .map( + |(gamma_power_offset, factor)| SumcheckOutputEvalFamilySharedTermPlan { + gamma_power_offset, + factor, + }, + ) + .collect(); + let mut item_terms = Vec::with_capacity(item_term_offsets.len()); + for (term_index, gamma_power_offset) in item_term_offsets.into_iter().enumerate() { + let start = term_index * evals.len(); + let end = start + evals.len(); + item_terms.push(SumcheckOutputEvalFamilyItemTermPlan { + gamma_power_offset, + factors: item_factors[start..end].to_vec(), + }); + } + Ok(SumcheckOutputEvalFamilyPlan { + symbol, + gamma, + evals, + power_stride: int_attr(operation, "power_stride")?, + value_term_offsets, + shared_terms, + item_terms, + }) +} + pub trait FieldExprDependencies { fn symbol(&self) -> &str; fn operands(&self) -> &[String]; @@ -535,3 +613,104 @@ fn usize_array(values: &[usize]) -> String { .collect::>() .join(", ") } + +fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { + operation + .attribute(attr) + .ok() + .and_then(string_attribute_value) + .ok_or_else(|| attr_error(operation, attr, "string")) +} + +fn symbol_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, EmitError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "symbol array"))?; + parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) +} + +fn parse_symbol_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned)) + .collect() +} + +fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { + operation + .attribute(attr) + .map(parse_integer_attr) + .ok() + .flatten() + .ok_or_else(|| attr_error(operation, attr, "integer")) +} + +fn parse_integer_attr(attribute: Attribute<'_>) -> Option { + attribute + .to_string() + .split_whitespace() + .next() + .and_then(|value| value.parse().ok()) +} + +fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, EmitError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "integer array"))?; + parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) +} + +fn parse_int_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| item.trim().parse().ok()) + .collect() +} + +fn operand_symbols( + operation: OperationRef<'_, '_>, + start_index: usize, + end_index: usize, +) -> Result, EmitError> { + (start_index..end_index) + .map(|index| operand_symbol(operation, index)) + .collect() +} + +fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result { + let operand = operation.operand(index).map_err(|_| { + EmitError::new(format!( + "{} requires operand {index}", + operation_name(operation) + )) + })?; + let owner = OperationResult::try_from(operand).map_err(|_| { + EmitError::new(format!( + "{} operand {index} must be an op result", + operation_name(operation) + )) + })?; + string_attr(owner.owner(), "sym_name") +} + +fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError { + EmitError::new(format!( + "{} attr `{attr}` is not a {expected}", + operation_name(operation) + )) +} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index fdd688079a..a932fe9829 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -10,10 +10,12 @@ use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; use super::output_claims::{ - FieldExprDependencies, StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan, + parse_output_eval_family_plan, FieldExprDependencies, + StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage6SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage6SumcheckOutputClaimPlan, + SumcheckOutputEvalFamilyPlan as Stage6SumcheckOutputEvalFamilyPlan, }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; @@ -36,6 +38,7 @@ pub struct Stage6CpuProgram { pub instance_results: Vec, pub evals: Vec, pub output_values: Vec, + pub output_families: Vec, pub output_claims: Vec, pub point_zeros: Vec, pub point_slices: Vec, @@ -272,6 +275,7 @@ impl Stage6CpuProgram { let mut instance_results = Vec::new(); let mut evals = Vec::new(); let mut output_values = Vec::new(); + let mut output_families = Vec::new(); let mut output_claim_asts = Vec::new(); let mut point_zeros = Vec::new(); let mut point_slices = Vec::new(); @@ -503,6 +507,9 @@ impl Stage6CpuProgram { }, }); } + "cpu.sumcheck_output_eval_family" => { + output_families.push(parse_output_eval_family_plan("stage6", op)?); + } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage6SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, @@ -585,7 +592,7 @@ impl Stage6CpuProgram { super::output_claims::resolve_output_claims( "stage6", &output_values, - &[], + &output_families, output_claim_asts, )? } else { @@ -608,6 +615,7 @@ impl Stage6CpuProgram { instance_results, evals, output_values, + output_families, output_claims, point_zeros, point_slices, @@ -713,6 +721,9 @@ impl Stage6CpuProgram { values.extend(symbols( self.output_values.iter().map(|value| &value.symbol), )); + values.extend(symbols( + self.output_families.iter().map(|family| &family.symbol), + )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); values @@ -922,7 +933,7 @@ impl Stage6CpuProgram { super::output_claims::verify_output_claims( "stage6", &self.output_values, - &[], + &self.output_families, &self.output_claims, &relations, &field_values, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 86f54507c9..fcff20dcef 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -10,13 +10,12 @@ use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; use super::output_claims::{ - FieldExprDependencies, StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan, + parse_output_eval_family_plan, FieldExprDependencies, + StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage7SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage7SumcheckOutputClaimPlan, - SumcheckOutputEvalFamilyItemTermPlan as Stage7SumcheckOutputEvalFamilyItemTermPlan, SumcheckOutputEvalFamilyPlan as Stage7SumcheckOutputEvalFamilyPlan, - SumcheckOutputEvalFamilySharedTermPlan as Stage7SumcheckOutputEvalFamilySharedTermPlan, }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; @@ -509,7 +508,7 @@ impl Stage7CpuProgram { }); } "cpu.sumcheck_output_eval_family" => { - output_families.push(output_eval_family_plan(op)?); + output_families.push(parse_output_eval_family_plan("stage7", op)?); } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage7SumcheckOutputClaimAst { @@ -2523,79 +2522,6 @@ fn symbols<'a>(values: impl Iterator) -> BTreeSet { values.cloned().collect() } -fn output_eval_family_plan( - operation: OperationRef<'_, '_>, -) -> Result { - let symbol = string_attr(operation, "sym_name")?; - let evals = symbol_array_attr(operation, "evals")?; - let shared_factors = symbol_array_attr(operation, "shared_terms")?; - let item_factors = symbol_array_attr(operation, "item_terms")?; - let value_term_offsets = int_array_attr(operation, "value_term_offsets")?; - let shared_term_offsets = int_array_attr(operation, "shared_term_offsets")?; - let item_term_offsets = int_array_attr(operation, "item_term_offsets")?; - verify_count( - "output eval family shared terms", - &symbol, - shared_term_offsets.len(), - shared_factors.len(), - )?; - verify_count( - "output eval family item term factors", - &symbol, - item_term_offsets.len() * evals.len(), - item_factors.len(), - )?; - let gamma = operand_symbol(operation, 0)?; - let eval_operands = operand_symbols_range(operation, 1, 1 + evals.len())?; - if evals != eval_operands { - return Err(EmitError::new(format!( - "stage7 output eval family @{symbol} evals do not match operands" - ))); - } - let shared_start = 1 + evals.len(); - let shared_end = shared_start + shared_factors.len(); - let shared_operands = operand_symbols_range(operation, shared_start, shared_end)?; - if shared_factors != shared_operands { - return Err(EmitError::new(format!( - "stage7 output eval family @{symbol} shared_terms do not match operands" - ))); - } - let item_operands = operand_symbols_range(operation, shared_end, operation.operand_count())?; - if item_factors != item_operands { - return Err(EmitError::new(format!( - "stage7 output eval family @{symbol} item_terms do not match operands" - ))); - } - let shared_terms = shared_term_offsets - .into_iter() - .zip(shared_factors) - .map( - |(gamma_power_offset, factor)| Stage7SumcheckOutputEvalFamilySharedTermPlan { - gamma_power_offset, - factor, - }, - ) - .collect(); - let mut item_terms = Vec::with_capacity(item_term_offsets.len()); - for (term_index, gamma_power_offset) in item_term_offsets.into_iter().enumerate() { - let start = term_index * evals.len(); - let end = start + evals.len(); - item_terms.push(Stage7SumcheckOutputEvalFamilyItemTermPlan { - gamma_power_offset, - factors: item_factors[start..end].to_vec(), - }); - } - Ok(Stage7SumcheckOutputEvalFamilyPlan { - symbol, - gamma, - evals, - power_stride: int_attr(operation, "power_stride")?, - value_term_offsets, - shared_terms, - item_terms, - }) -} - fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) @@ -2676,15 +2602,7 @@ fn operand_symbols( operation: OperationRef<'_, '_>, start_index: usize, ) -> Result, EmitError> { - operand_symbols_range(operation, start_index, operation.operand_count()) -} - -fn operand_symbols_range( - operation: OperationRef<'_, '_>, - start_index: usize, - end_index: usize, -) -> Result, EmitError> { - (start_index..end_index) + (start_index..operation.operand_count()) .map(|index| operand_symbol(operation, index)) .collect() } diff --git a/crates/bolt/src/protocols/jolt/phases/stage6.rs b/crates/bolt/src/protocols/jolt/phases/stage6.rs index a8389a3d00..5ed675e57d 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage6.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage6.rs @@ -11,7 +11,8 @@ use super::super::oracles; use super::super::params::JoltProtocolParams; use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type}; use super::sumcheck_output::{ - append_structured_polynomial_eval, append_sumcheck_output_claim, OutputClaimSpec, + append_structured_polynomial_eval, append_sumcheck_output_claim, + append_sumcheck_output_eval_family, OutputClaimSpec, OutputEvalFamilySpec, StructuredPolynomialPointSpec, StructuredPolynomialSpec, }; @@ -1969,68 +1970,43 @@ fn append_stage6_inc_output_claim<'c, 'a>( inc.0, inputs.rd_inc_stage5.point, )?; - let ram_stage4_term = append_field_mul( + let claim = append_sumcheck_output_eval_family( context, module, - "stage6.inc_claim_reduction.output.term.RamIncStage4", - gamma, - eq_ram_stage4, - )?; - let ram_eq_combined = append_field_add( - context, - module, - "stage6.inc_claim_reduction.output.eq.RamCombined", - eq_ram_stage2, - ram_stage4_term, - )?; - let ram_term = append_field_mul( - context, - module, - "stage6.inc_claim_reduction.output.term.RamInc", - output_evals.ram_inc, - ram_eq_combined, - )?; - let rd_stage5_term = append_field_mul( - context, - module, - "stage6.inc_claim_reduction.output.term.RdIncStage5", - gamma, - eq_rd_stage5, - )?; - let rd_eq_combined = append_field_add( - context, - module, - "stage6.inc_claim_reduction.output.eq.RdCombined", - eq_rd_stage4, - rd_stage5_term, - )?; - let rd_eval_term = append_field_mul( - context, - module, - "stage6.inc_claim_reduction.output.term.RdInc", - output_evals.rd_inc, - rd_eq_combined, - )?; - let gamma2 = append_field_pow( - context, - module, - "stage6.inc_claim_reduction.output.gamma2", + OutputEvalFamilySpec { + symbol: "stage6.inc_claim_reduction.output.family", + power_stride: 2, + value_term_offsets: &[], + shared_term_offsets: &[], + item_term_offsets: &[0, 1], + }, gamma, - 2, - )?; - let rd_term = append_field_mul( - context, - module, - "stage6.inc_claim_reduction.output.term.RdWeighted", - gamma2, - rd_eval_term, - )?; - let claim = append_field_add( - context, - module, - "stage6.inc_claim_reduction.output.claim_expr", - ram_term, - rd_term, + &[ + ( + "stage6.inc_claim_reduction.eval.RamInc", + output_evals.ram_inc, + ), + ("stage6.inc_claim_reduction.eval.RdInc", output_evals.rd_inc), + ], + &[], + &[ + ( + "stage6.inc_claim_reduction.output.eq.RamIncStage2", + eq_ram_stage2, + ), + ( + "stage6.inc_claim_reduction.output.eq.RdIncStage4", + eq_rd_stage4, + ), + ( + "stage6.inc_claim_reduction.output.eq.RamIncStage4", + eq_ram_stage4, + ), + ( + "stage6.inc_claim_reduction.output.eq.RdIncStage5", + eq_rd_stage5, + ), + ], )?; append_sumcheck_output_claim( context, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index adfd3f41b0..c8427eddf8 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -920,6 +920,8 @@ fn jolt_stage6_protocol_defines_bytecode_booleanity_and_virtualization_flow() { assert!(text.contains("sym_name = \"stage6.ram_ra_virtual.output.claim\"")); assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.output.claim\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.claim\"")); + assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.family\"")); + assert!(text.contains("\"piop.sumcheck_output_eval_family\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.eq.RdIncStage5\"")); assert!(!text.contains("kernel = @")); assert!(!text.contains("\"compute.")); @@ -975,6 +977,7 @@ fn jolt_stage6_lowers_to_compute_and_cpu_role_ir() { assert!(prover_cpu_text.contains("point_order = \"bytecode_read_raf\"")); assert!(verifier_cpu_text.contains("\"cpu.sumcheck_verify_claim\"")); assert!(verifier_cpu_text.contains("\"cpu.structured_polynomial_eval\"")); + assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_eval_family\"")); assert!(verifier_cpu_text.contains("\"cpu.sumcheck_output_claim\"")); assert!(!verifier_kernel_text.contains("kernel = @")); assert!(!verifier_cpu_text.contains("kernel = @")); @@ -1519,7 +1522,48 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(prover_program.output_values.len(), 7); assert!(prover_program.output_claims.is_empty()); assert_eq!(verifier_program.output_values.len(), 7); + assert_eq!(verifier_program.output_families.len(), 1); assert_eq!(verifier_program.output_claims.len(), 4); + let inc_family = &verifier_program.output_families[0]; + assert_eq!( + inc_family.symbol, + "stage6.inc_claim_reduction.output.family" + ); + assert_eq!(inc_family.gamma, "stage6.inc_claim_reduction.gamma"); + assert_eq!( + inc_family.evals, + vec![ + "stage6.inc_claim_reduction.eval.RamInc".to_owned(), + "stage6.inc_claim_reduction.eval.RdInc".to_owned() + ] + ); + assert_eq!(inc_family.power_stride, 2); + assert!(inc_family.value_term_offsets.is_empty()); + assert!(inc_family.shared_terms.is_empty()); + assert_eq!(inc_family.item_terms.len(), 2); + assert_eq!(inc_family.item_terms[0].gamma_power_offset, 0); + assert_eq!( + inc_family.item_terms[0].factors, + vec![ + "stage6.inc_claim_reduction.output.eq.RamIncStage2".to_owned(), + "stage6.inc_claim_reduction.output.eq.RdIncStage4".to_owned() + ] + ); + assert_eq!(inc_family.item_terms[1].gamma_power_offset, 1); + assert_eq!( + inc_family.item_terms[1].factors, + vec![ + "stage6.inc_claim_reduction.output.eq.RamIncStage4".to_owned(), + "stage6.inc_claim_reduction.output.eq.RdIncStage5".to_owned() + ] + ); + let inc_claims = verifier_program + .output_claims + .iter() + .filter(|claim| claim.claim_value == "stage6.inc_claim_reduction.output.family") + .collect::>(); + assert_eq!(inc_claims.len(), 1); + assert_eq!(inc_claims[0].eval_families, vec![inc_family.clone()]); assert_eq!(prover_program.point_zeros.len(), 1); assert_eq!( prover_program.point_slices.len(), @@ -1623,9 +1667,18 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("Stage6SumcheckOutputClaimPlan")); + assert!(verifier_source + .source + .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES")); assert!(verifier_source .source .contains("stage6.inc_claim_reduction.output.eq.RdIncStage5")); + assert!(!verifier_source + .source + .contains("stage6.inc_claim_reduction.output.term.RamInc")); + assert!(!verifier_source + .source + .contains("stage6.inc_claim_reduction.output.gamma2")); assert!(verifier_source .source .contains("stage6.bytecode_read_raf.eval.BytecodeRa_0")); diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 73995900ce..e22569607d 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -360,8 +360,7 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_3", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_18"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_19"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_4", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_22"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_23"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_5", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_26"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_27"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_6", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_30"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_31"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_7", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial0", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial2", "stage6.instruction_ra_virtual.output.term.InstructionRa_1"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial0", "stage6.instruction_ra_virtual.output.term.InstructionRa_2"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial1", "stage6.instruction_ra_virtual.output.term.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial2", "stage6.instruction_ra_virtual.output.term.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial3", "stage6.instruction_ra_virtual.output.term.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial4", "stage6.instruction_ra_virtual.output.term.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial5", "stage6.instruction_ra_virtual.output.term.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.eq.Cycle", "stage6.instruction_ra_virtual.output.weighted_sum.partial6"]), stage6_field_expr("stage6.inc_claim_reduction.output.term.RamIncStage4", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.gamma", "stage6.inc_claim_reduction.output.eq.RamIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.eq.RamCombined", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.term.RamIncStage4"]), - stage6_field_expr("stage6.inc_claim_reduction.output.term.RamInc", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.eq.RamCombined"]), stage6_field_expr("stage6.inc_claim_reduction.output.term.RdIncStage5", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.gamma", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.eq.RdCombined", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.output.eq.RdIncStage4", "stage6.inc_claim_reduction.output.term.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.term.RdInc", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.eq.RdCombined"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term.RdWeighted", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.output.gamma2", "stage6.inc_claim_reduction.output.term.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.output.term.RamInc", "stage6.inc_claim_reduction.output.term.RdWeighted"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial1", "stage6.instruction_ra_virtual.output.term.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial2", "stage6.instruction_ra_virtual.output.term.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial3", "stage6.instruction_ra_virtual.output.term.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial4", "stage6.instruction_ra_virtual.output.term.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial5", "stage6.instruction_ra_virtual.output.term.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.eq.Cycle", "stage6.instruction_ra_virtual.output.weighted_sum.partial6"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -631,11 +630,26 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES: &[Stage6StructuredPolynomialEva Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.registers_val_evaluation.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_EVALS: &[&str] = &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.eval.RdInc"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_VALUE_TERM_OFFSETS: &[usize] = &[]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan] = &[ + +]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERM_0_FACTORS: &[&str] = &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERM_1_FACTORS: &[&str] = &["stage6.inc_claim_reduction.output.eq.RamIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 0, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 1, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERM_1_FACTORS }, +]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan] = &[ + bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage6.inc_claim_reduction.output.family", gamma: "stage6.inc_claim_reduction.gamma", evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_EVALS, power_stride: 2, value_term_offsets: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_VALUE_TERM_OFFSETS, shared_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_SHARED_TERMS, item_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERMS }, +]; + pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[ Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], claim_value: "stage6.hamming_booleanity.output.claim_expr" }, Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], claim_value: "stage6.ram_ra_virtual.output.claim_expr" }, Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], claim_value: "stage6.instruction_ra_virtual.output.claim_expr" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: &[], claim_value: "stage6.inc_claim_reduction.output.claim_expr" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES, claim_value: "stage6.inc_claim_reduction.output.family" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { From 97b50d9cb4471c01aff67f72dab973e92a043f64 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 16:59:53 -0600 Subject: [PATCH 034/171] fix(bolt): resolve output family dependencies --- .../protocols/jolt/emit/rust/output_claims.rs | 145 +++++++++++++++++- .../src/protocols/jolt/emit/rust/stage3.rs | 1 + .../src/protocols/jolt/emit/rust/stage4.rs | 1 + .../src/protocols/jolt/emit/rust/stage5.rs | 1 + .../src/protocols/jolt/emit/rust/stage6.rs | 1 + .../src/protocols/jolt/emit/rust/stage7.rs | 1 + 6 files changed, 144 insertions(+), 6 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index cf2e84f984..df11c49f5c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -141,12 +141,16 @@ pub trait FieldExprDependencies { fn operands(&self) -> &[String]; } -pub fn resolve_output_claims( +pub fn resolve_output_claims( stage: &str, output_values: &[StructuredPolynomialEvalPlan], output_families: &[SumcheckOutputEvalFamilyPlan], + field_exprs: &[T], claim_asts: Vec, -) -> Result, EmitError> { +) -> Result, EmitError> +where + T: FieldExprDependencies, +{ let output_values_by_symbol: BTreeMap<_, _> = output_values .iter() .map(|value| (value.symbol.as_str(), value)) @@ -155,6 +159,10 @@ pub fn resolve_output_claims( .iter() .map(|family| (family.symbol.as_str(), family)) .collect(); + let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs + .iter() + .map(|expr| (expr.symbol(), expr)) + .collect(); claim_asts .into_iter() .map(|claim| { @@ -186,10 +194,16 @@ pub fn resolve_output_claims( }) }) .collect::, EmitError>>()?; - let eval_families = output_families_by_symbol - .get(claim.claim_value.as_str()) - .map(|family| vec![(*family).clone()]) - .unwrap_or_default(); + let eval_family_symbols = output_family_dependency_closure( + &output_families_by_symbol, + &field_exprs_by_symbol, + std::iter::once(claim.claim_value.as_str()), + ); + let eval_families = output_families + .iter() + .filter(|family| eval_family_symbols.contains(&family.symbol)) + .cloned() + .collect(); Ok(SumcheckOutputClaimPlan { relation: claim.relation, polynomial_evals, @@ -200,6 +214,40 @@ pub fn resolve_output_claims( .collect() } +fn output_family_dependency_closure<'a, T>( + output_families_by_symbol: &BTreeMap<&str, &SumcheckOutputEvalFamilyPlan>, + field_exprs_by_symbol: &BTreeMap<&str, &T>, + roots: impl Iterator, +) -> BTreeSet +where + T: FieldExprDependencies, +{ + let mut visited = BTreeSet::new(); + let mut output_families = BTreeSet::new(); + let mut stack = roots.map(str::to_owned).collect::>(); + while let Some(symbol) = stack.pop() { + if !visited.insert(symbol.clone()) { + continue; + } + if let Some(family) = output_families_by_symbol.get(symbol.as_str()) { + let _inserted = output_families.insert(family.symbol.clone()); + stack.push(family.gamma.clone()); + stack.extend(family.evals.iter().cloned()); + stack.extend(family.shared_terms.iter().map(|term| term.factor.clone())); + stack.extend( + family + .item_terms + .iter() + .flat_map(|term| term.factors.iter().cloned()), + ); + } + if let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) { + stack.extend(expr.operands().iter().cloned()); + } + } + output_families +} + pub fn prune_output_only_field_exprs<'a, 'b, T>( field_exprs: &mut Vec, sumcheck_claim_roots: impl Iterator, @@ -614,6 +662,91 @@ fn usize_array(values: &[usize]) -> String { .join(", ") } +#[cfg(test)] +mod tests { + use super::{ + resolve_output_claims, FieldExprDependencies, SumcheckOutputClaimAst, + SumcheckOutputEvalFamilyItemTermPlan, SumcheckOutputEvalFamilyPlan, + SumcheckOutputEvalFamilySharedTermPlan, + }; + + struct TestFieldExpr { + symbol: String, + operands: Vec, + } + + impl FieldExprDependencies for TestFieldExpr { + fn symbol(&self) -> &str { + &self.symbol + } + + fn operands(&self) -> &[String] { + &self.operands + } + } + + #[test] + fn resolves_output_families_reachable_through_field_expressions() { + let inner_family = SumcheckOutputEvalFamilyPlan { + symbol: "inner.family".to_owned(), + gamma: "inner.gamma".to_owned(), + evals: vec!["inner.eval".to_owned()], + power_stride: 1, + value_term_offsets: vec![0], + shared_terms: Vec::new(), + item_terms: Vec::new(), + }; + let outer_family = SumcheckOutputEvalFamilyPlan { + symbol: "outer.family".to_owned(), + gamma: "outer.gamma".to_owned(), + evals: vec!["outer.eval".to_owned()], + power_stride: 1, + value_term_offsets: Vec::new(), + shared_terms: vec![SumcheckOutputEvalFamilySharedTermPlan { + gamma_power_offset: 0, + factor: "outer.shared.factor".to_owned(), + }], + item_terms: vec![SumcheckOutputEvalFamilyItemTermPlan { + gamma_power_offset: 1, + factors: vec!["factor.expr".to_owned()], + }], + }; + let field_exprs = vec![ + TestFieldExpr { + symbol: "claim.expr".to_owned(), + operands: vec!["outer.family".to_owned()], + }, + TestFieldExpr { + symbol: "factor.expr".to_owned(), + operands: vec!["inner.family".to_owned()], + }, + ]; + let claim_asts = vec![SumcheckOutputClaimAst { + relation: "relation".to_owned(), + polynomial_evals: Vec::new(), + polynomial_eval_operands: Vec::new(), + claim_value: "claim.expr".to_owned(), + }]; + + let claims = match resolve_output_claims( + "test", + &[], + &[inner_family, outer_family], + &field_exprs, + claim_asts, + ) { + Ok(claims) => claims, + Err(err) => panic!("unexpected output claim resolution error: {err:?}"), + }; + let family_symbols = claims[0] + .eval_families + .iter() + .map(|family| family.symbol.as_str()) + .collect::>(); + assert_eq!(family_symbols, vec!["inner.family", "outer.family"]); + } +} + fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 325c41ec6f..0632463fe1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -559,6 +559,7 @@ impl Stage3CpuProgram { "stage3", &output_values, &[], + &field_exprs, output_claim_asts, )? } else { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 19b9783e08..331ad9c05f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -570,6 +570,7 @@ impl Stage4CpuProgram { "stage4", &output_values, &[], + &field_exprs, output_claim_asts, )? } else { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 8a35b9521b..40f26d3bc9 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -570,6 +570,7 @@ impl Stage5CpuProgram { "stage5", &output_values, &[], + &field_exprs, output_claim_asts, )? } else { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index a932fe9829..113954290a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -593,6 +593,7 @@ impl Stage6CpuProgram { "stage6", &output_values, &output_families, + &field_exprs, output_claim_asts, )? } else { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index fcff20dcef..a91004cbd3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -593,6 +593,7 @@ impl Stage7CpuProgram { "stage7", &output_values, &output_families, + &field_exprs, output_claim_asts, )? } else { From 691166c92769d70aa1ee4a6f378f4582e1db47be Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 17:33:40 -0600 Subject: [PATCH 035/171] refactor(bolt): add output product families Add typed product-family output-claim plans across the Bolt IR, Rust emitter, verifier runtime, and jolt-equivalence adapter. Cut Stage 6 RAM RA virtual and instruction RA virtual output claims over to semantic product-family plans and regenerate the checked-in role artifacts. --- crates/bolt-verifier-runtime/src/lib.rs | 50 ++ crates/bolt/irdl/compute.mlir | 19 + crates/bolt/irdl/cpu.mlir | 19 + crates/bolt/irdl/piop.mlir | 19 + .../protocols/jolt/emit/rust/output_claims.rs | 481 ++++++++++++++---- .../src/protocols/jolt/emit/rust/stage3.rs | 16 +- .../src/protocols/jolt/emit/rust/stage4.rs | 16 +- .../src/protocols/jolt/emit/rust/stage5.rs | 16 +- .../src/protocols/jolt/emit/rust/stage6.rs | 30 +- .../src/protocols/jolt/emit/rust/stage7.rs | 30 +- .../src/protocols/jolt/phases/commitment.rs | 23 + .../src/protocols/jolt/phases/lowering.rs | 23 + .../bolt/src/protocols/jolt/phases/stage1.rs | 23 + .../bolt/src/protocols/jolt/phases/stage6.rs | 129 +++-- .../protocols/jolt/phases/sumcheck_output.rs | 72 +++ crates/bolt/src/schema.rs | 100 ++++ crates/bolt/tests/commitment_ir.rs | 120 ++++- crates/jolt-equivalence/src/plan_adapters.rs | 32 ++ crates/jolt-prover/src/stages/stage6.rs | 1 + crates/jolt-verifier/src/stages/stage3.rs | 6 +- crates/jolt-verifier/src/stages/stage4.rs | 4 +- crates/jolt-verifier/src/stages/stage5.rs | 4 +- crates/jolt-verifier/src/stages/stage6.rs | 56 +- crates/jolt-verifier/src/stages/stage7.rs | 2 +- 24 files changed, 1073 insertions(+), 218 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index f9727a53e2..95a83e2fd1 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -378,11 +378,26 @@ pub struct SumcheckOutputEvalFamilyPlan { pub item_terms: &'static [SumcheckOutputEvalFamilyItemTermPlan], } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct SumcheckOutputProductFamilyTermPlan { + pub gamma_power_offset: usize, + pub evals: &'static [&'static str], + pub factors: &'static [&'static str], +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct SumcheckOutputProductFamilyPlan { + pub symbol: &'static str, + pub gamma: &'static str, + pub terms: &'static [SumcheckOutputProductFamilyTermPlan], +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct SumcheckOutputClaimPlan { pub relation: R, pub polynomial_evals: &'static [StructuredPolynomialEvalPlan], pub eval_families: &'static [SumcheckOutputEvalFamilyPlan], + pub product_families: &'static [SumcheckOutputProductFamilyPlan], pub claim_value: &'static str, } @@ -1198,6 +1213,10 @@ pub fn evaluate_sumcheck_output_claim( let value = evaluate_sumcheck_output_eval_family(family, store, &scratch)?; scratch.insert(family.symbol, value); } + for family in plan.product_families { + let value = evaluate_sumcheck_output_product_family(family, store, &scratch)?; + scratch.insert(family.symbol, value); + } evaluate_available_field_exprs_with_scratch(field_exprs, store, &mut scratch)?; scratch .scalar_or(store, plan.claim_value) @@ -1272,6 +1291,37 @@ fn evaluate_sumcheck_output_eval_family( Ok(result) } +fn evaluate_sumcheck_output_product_family( + family: &SumcheckOutputProductFamilyPlan, + store: &ValueStore, + scratch: &ScratchScalars, +) -> Result { + let gamma = scratch + .scalar_or(store, family.gamma) + .ok_or(RuntimePlanError::MissingValue { + symbol: family.gamma, + })?; + let mut result = Fr::from_u64(0); + for term in family.terms { + if term.evals.is_empty() && term.factors.is_empty() { + return Err(RuntimePlanError::InvalidInputLength { + input: family.symbol, + expected: 1, + actual: 0, + }); + } + let mut product = pow_field(gamma, term.gamma_power_offset); + for &symbol in term.evals.iter().chain(term.factors.iter()) { + let value = scratch + .scalar_or(store, symbol) + .ok_or(RuntimePlanError::MissingValue { symbol })?; + product *= value; + } + result += product; + } + Ok(result) +} + fn evaluate_structured_polynomial_point( plan: StructuredPolynomialPointPlan, raw_point: &[Fr], diff --git a/crates/bolt/irdl/compute.mlir b/crates/bolt/irdl/compute.mlir index 03ac0ab091..48030710bf 100644 --- a/crates/bolt/irdl/compute.mlir +++ b/crates/bolt/irdl/compute.mlir @@ -717,6 +717,25 @@ irdl.dialect @compute { irdl.operands(gamma: %value, inputs: variadic %value) irdl.results(value: %value) } + irdl.operation @sumcheck_output_product_family { + %value = irdl.parametric @compute::@field_value<> + %sym = irdl.any + %term_gamma_power_offsets = irdl.any + %term_eval_counts = irdl.any + %term_factor_counts = irdl.any + %evals = irdl.any + %factors = irdl.any + irdl.attributes { + "sym_name" = %sym, + "term_gamma_power_offsets" = %term_gamma_power_offsets, + "term_eval_counts" = %term_eval_counts, + "term_factor_counts" = %term_factor_counts, + "evals" = %evals, + "factors" = %factors + } + irdl.operands(gamma: %value, inputs: variadic %value) + irdl.results(value: %value) + } irdl.operation @sumcheck_output_claim { %value = irdl.parametric @compute::@field_value<> %sym = irdl.any diff --git a/crates/bolt/irdl/cpu.mlir b/crates/bolt/irdl/cpu.mlir index a7ade05045..ae28f315fb 100644 --- a/crates/bolt/irdl/cpu.mlir +++ b/crates/bolt/irdl/cpu.mlir @@ -647,6 +647,25 @@ irdl.dialect @cpu { irdl.operands(gamma: %value, inputs: variadic %value) irdl.results(value: %value) } + irdl.operation @sumcheck_output_product_family { + %value = irdl.parametric @cpu::@field_value<> + %sym = irdl.any + %term_gamma_power_offsets = irdl.any + %term_eval_counts = irdl.any + %term_factor_counts = irdl.any + %evals = irdl.any + %factors = irdl.any + irdl.attributes { + "sym_name" = %sym, + "term_gamma_power_offsets" = %term_gamma_power_offsets, + "term_eval_counts" = %term_eval_counts, + "term_factor_counts" = %term_factor_counts, + "evals" = %evals, + "factors" = %factors + } + irdl.operands(gamma: %value, inputs: variadic %value) + irdl.results(value: %value) + } irdl.operation @sumcheck_output_claim { %value = irdl.parametric @cpu::@field_value<> %sym = irdl.any diff --git a/crates/bolt/irdl/piop.mlir b/crates/bolt/irdl/piop.mlir index 1253f1a405..c1b320732a 100644 --- a/crates/bolt/irdl/piop.mlir +++ b/crates/bolt/irdl/piop.mlir @@ -265,6 +265,25 @@ irdl.dialect @piop { irdl.operands(gamma: %value, inputs: variadic %value) irdl.results(value: %value) } + irdl.operation @sumcheck_output_product_family { + %value = irdl.parametric @field::@scalar<> + %sym = irdl.any + %term_gamma_power_offsets = irdl.any + %term_eval_counts = irdl.any + %term_factor_counts = irdl.any + %evals = irdl.any + %factors = irdl.any + irdl.attributes { + "sym_name" = %sym, + "term_gamma_power_offsets" = %term_gamma_power_offsets, + "term_eval_counts" = %term_eval_counts, + "term_factor_counts" = %term_factor_counts, + "evals" = %evals, + "factors" = %factors + } + irdl.operands(gamma: %value, inputs: variadic %value) + irdl.results(value: %value) + } irdl.operation @sumcheck_output_claim { %value = irdl.parametric @field::@scalar<> %sym = irdl.any diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index df11c49f5c..584fd4749f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -46,11 +46,26 @@ pub struct SumcheckOutputEvalFamilyPlan { pub item_terms: Vec, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputProductFamilyTermPlan { + pub gamma_power_offset: usize, + pub evals: Vec, + pub factors: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputProductFamilyPlan { + pub symbol: String, + pub gamma: String, + pub terms: Vec, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct SumcheckOutputClaimPlan { pub relation: String, pub polynomial_evals: Vec, pub eval_families: Vec, + pub product_families: Vec, pub claim_value: String, } @@ -136,6 +151,84 @@ pub fn parse_output_eval_family_plan( }) } +pub fn parse_output_product_family_plan( + stage: &str, + operation: OperationRef<'_, '_>, +) -> Result { + let symbol = string_attr(operation, "sym_name")?; + let evals = symbol_array_attr(operation, "evals")?; + let factors = symbol_array_attr(operation, "factors")?; + let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; + let term_eval_counts = int_array_attr(operation, "term_eval_counts")?; + let term_factor_counts = int_array_attr(operation, "term_factor_counts")?; + verify_count( + "output product family term eval counts", + &symbol, + term_gamma_power_offsets.len(), + term_eval_counts.len(), + )?; + verify_count( + "output product family term factor counts", + &symbol, + term_gamma_power_offsets.len(), + term_factor_counts.len(), + )?; + verify_count( + "output product family evals", + &symbol, + term_eval_counts.iter().sum(), + evals.len(), + )?; + verify_count( + "output product family factors", + &symbol, + term_factor_counts.iter().sum(), + factors.len(), + )?; + let gamma = operand_symbol(operation, 0)?; + let eval_end = 1 + evals.len(); + let eval_operands = operand_symbols(operation, 1, eval_end)?; + if evals != eval_operands { + return Err(EmitError::new(format!( + "{stage} output product family @{symbol} evals do not match operands" + ))); + } + let factor_operands = operand_symbols(operation, eval_end, operation.operand_count())?; + if factors != factor_operands { + return Err(EmitError::new(format!( + "{stage} output product family @{symbol} factors do not match operands" + ))); + } + let mut eval_offset = 0; + let mut factor_offset = 0; + let mut terms = Vec::with_capacity(term_gamma_power_offsets.len()); + for ((gamma_power_offset, eval_count), factor_count) in term_gamma_power_offsets + .into_iter() + .zip(term_eval_counts) + .zip(term_factor_counts) + { + if eval_count == 0 && factor_count == 0 { + return Err(EmitError::new(format!( + "{stage} output product family @{symbol} has an empty term" + ))); + } + let eval_end = eval_offset + eval_count; + let factor_end = factor_offset + factor_count; + terms.push(SumcheckOutputProductFamilyTermPlan { + gamma_power_offset, + evals: evals[eval_offset..eval_end].to_vec(), + factors: factors[factor_offset..factor_end].to_vec(), + }); + eval_offset = eval_end; + factor_offset = factor_end; + } + Ok(SumcheckOutputProductFamilyPlan { + symbol, + gamma, + terms, + }) +} + pub trait FieldExprDependencies { fn symbol(&self) -> &str; fn operands(&self) -> &[String]; @@ -145,6 +238,7 @@ pub fn resolve_output_claims( stage: &str, output_values: &[StructuredPolynomialEvalPlan], output_families: &[SumcheckOutputEvalFamilyPlan], + output_product_families: &[SumcheckOutputProductFamilyPlan], field_exprs: &[T], claim_asts: Vec, ) -> Result, EmitError> @@ -159,6 +253,10 @@ where .iter() .map(|family| (family.symbol.as_str(), family)) .collect(); + let output_product_families_by_symbol: BTreeMap<_, _> = output_product_families + .iter() + .map(|family| (family.symbol.as_str(), family)) + .collect(); let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs .iter() .map(|expr| (expr.symbol(), expr)) @@ -194,43 +292,57 @@ where }) }) .collect::, EmitError>>()?; - let eval_family_symbols = output_family_dependency_closure( + let family_symbols = output_family_dependency_closure( &output_families_by_symbol, + &output_product_families_by_symbol, &field_exprs_by_symbol, std::iter::once(claim.claim_value.as_str()), ); let eval_families = output_families .iter() - .filter(|family| eval_family_symbols.contains(&family.symbol)) + .filter(|family| family_symbols.eval_families.contains(&family.symbol)) + .cloned() + .collect(); + let product_families = output_product_families + .iter() + .filter(|family| family_symbols.product_families.contains(&family.symbol)) .cloned() .collect(); Ok(SumcheckOutputClaimPlan { relation: claim.relation, polynomial_evals, eval_families, + product_families, claim_value: claim.claim_value, }) }) .collect() } +struct OutputFamilyDependencyClosure { + eval_families: BTreeSet, + product_families: BTreeSet, +} + fn output_family_dependency_closure<'a, T>( output_families_by_symbol: &BTreeMap<&str, &SumcheckOutputEvalFamilyPlan>, + output_product_families_by_symbol: &BTreeMap<&str, &SumcheckOutputProductFamilyPlan>, field_exprs_by_symbol: &BTreeMap<&str, &T>, roots: impl Iterator, -) -> BTreeSet +) -> OutputFamilyDependencyClosure where T: FieldExprDependencies, { let mut visited = BTreeSet::new(); - let mut output_families = BTreeSet::new(); + let mut eval_families = BTreeSet::new(); + let mut product_families = BTreeSet::new(); let mut stack = roots.map(str::to_owned).collect::>(); while let Some(symbol) = stack.pop() { if !visited.insert(symbol.clone()) { continue; } if let Some(family) = output_families_by_symbol.get(symbol.as_str()) { - let _inserted = output_families.insert(family.symbol.clone()); + let _inserted = eval_families.insert(family.symbol.clone()); stack.push(family.gamma.clone()); stack.extend(family.evals.iter().cloned()); stack.extend(family.shared_terms.iter().map(|term| term.factor.clone())); @@ -241,11 +353,22 @@ where .flat_map(|term| term.factors.iter().cloned()), ); } + if let Some(family) = output_product_families_by_symbol.get(symbol.as_str()) { + let _inserted = product_families.insert(family.symbol.clone()); + stack.push(family.gamma.clone()); + for term in &family.terms { + stack.extend(term.evals.iter().cloned()); + stack.extend(term.factors.iter().cloned()); + } + } if let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) { stack.extend(expr.operands().iter().cloned()); } } - output_families + OutputFamilyDependencyClosure { + eval_families, + product_families, + } } pub fn prune_output_only_field_exprs<'a, 'b, T>( @@ -269,15 +392,29 @@ pub fn prune_output_only_field_exprs<'a, 'b, T>( }); } +pub struct OutputClaimVerification<'a> { + pub output_values: &'a [StructuredPolynomialEvalPlan], + pub output_families: &'a [SumcheckOutputEvalFamilyPlan], + pub output_product_families: &'a [SumcheckOutputProductFamilyPlan], + pub output_claims: &'a [SumcheckOutputClaimPlan], + pub relations: &'a BTreeSet, + pub field_values: &'a BTreeSet, + pub point_values: &'a BTreeSet, +} + pub fn verify_output_claims( stage: &str, - output_values: &[StructuredPolynomialEvalPlan], - output_families: &[SumcheckOutputEvalFamilyPlan], - output_claims: &[SumcheckOutputClaimPlan], - relations: &BTreeSet, - field_values: &BTreeSet, - point_values: &BTreeSet, + verification: OutputClaimVerification<'_>, ) -> Result<(), EmitError> { + let OutputClaimVerification { + output_values, + output_families, + output_product_families, + output_claims, + relations, + field_values, + point_values, + } = verification; for polynomial_eval in output_values { if !point_values.contains(&polynomial_eval.x_point.source) { return Err(EmitError::new(format!( @@ -343,6 +480,38 @@ pub fn verify_output_claims( } } } + for family in output_product_families { + if !field_values.contains(&family.gamma) { + return Err(EmitError::new(format!( + "{stage} output product family @{} references missing gamma @{}", + family.symbol, family.gamma + ))); + } + for term in &family.terms { + if term.evals.is_empty() && term.factors.is_empty() { + return Err(EmitError::new(format!( + "{stage} output product family @{} has an empty term", + family.symbol + ))); + } + for eval in &term.evals { + if !field_values.contains(eval) { + return Err(EmitError::new(format!( + "{stage} output product family @{} references missing eval @{}", + family.symbol, eval + ))); + } + } + for factor in &term.factors { + if !field_values.contains(factor) { + return Err(EmitError::new(format!( + "{stage} output product family @{} references missing factor @{}", + family.symbol, factor + ))); + } + } + } + } for claim in output_claims { if !relations.contains(&claim.relation) { return Err(EmitError::new(format!( @@ -393,8 +562,9 @@ pub fn emit_verifier_output_claim_constants( ), ); let eval_families = emit_eval_family_constants(&mut source, stage_type, index, claim); + let product_families = emit_product_family_constants(&mut source, stage_type, index, claim); claims.push(format!( - " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, claim_value: {} }},", + " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, product_families: {product_families}, claim_value: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, rust_str(&claim.claim_value) )); @@ -495,6 +665,66 @@ fn emit_eval_family_constants( families_name } +fn emit_product_family_constants( + source: &mut String, + stage_type: &str, + claim_index: usize, + claim: &SumcheckOutputClaimPlan, +) -> String { + if claim.product_families.is_empty() { + return "&[]".to_owned(); + } + let upper_stage = stage_type.to_ascii_uppercase(); + let mut family_rows = Vec::new(); + for (family_index, family) in claim.product_families.iter().enumerate() { + let prefix = format!( + "{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_PRODUCT_FAMILY_{family_index}" + ); + let mut term_rows = Vec::new(); + for (term_index, term) in family.terms.iter().enumerate() { + let evals_name = format!("{prefix}_TERM_{term_index}_EVALS"); + let evals = rust_str_array(&term.evals); + push_format( + source, + format_args!("pub const {evals_name}: &[&str] = &[{evals}];\n"), + ); + let factors_name = format!("{prefix}_TERM_{term_index}_FACTORS"); + let factors = rust_str_array(&term.factors); + push_format( + source, + format_args!("pub const {factors_name}: &[&str] = &[{factors}];\n"), + ); + term_rows.push(format!( + " bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan {{ gamma_power_offset: {}, evals: {evals_name}, factors: {factors_name} }},", + term.gamma_power_offset + )); + } + let terms_name = format!("{prefix}_TERMS"); + let terms = term_rows.join("\n"); + push_format( + source, + format_args!( + "pub const {terms_name}: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[\n{terms}\n];\n" + ), + ); + family_rows.push(format!( + " bolt_verifier_runtime::SumcheckOutputProductFamilyPlan {{ symbol: {}, gamma: {}, terms: {terms_name} }},", + rust_str(&family.symbol), + rust_str(&family.gamma), + )); + } + let families_name = + format!("{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_PRODUCT_FAMILIES"); + let families = family_rows.join("\n"); + push_format( + source, + format_args!( + "pub const {families_name}: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[\n{families}\n];\n\n" + ), + ); + families_name +} + fn field_expr_dependency_closure<'a, T>( field_exprs_by_symbol: &BTreeMap<&str, &T>, roots: impl Iterator, @@ -662,91 +892,6 @@ fn usize_array(values: &[usize]) -> String { .join(", ") } -#[cfg(test)] -mod tests { - use super::{ - resolve_output_claims, FieldExprDependencies, SumcheckOutputClaimAst, - SumcheckOutputEvalFamilyItemTermPlan, SumcheckOutputEvalFamilyPlan, - SumcheckOutputEvalFamilySharedTermPlan, - }; - - struct TestFieldExpr { - symbol: String, - operands: Vec, - } - - impl FieldExprDependencies for TestFieldExpr { - fn symbol(&self) -> &str { - &self.symbol - } - - fn operands(&self) -> &[String] { - &self.operands - } - } - - #[test] - fn resolves_output_families_reachable_through_field_expressions() { - let inner_family = SumcheckOutputEvalFamilyPlan { - symbol: "inner.family".to_owned(), - gamma: "inner.gamma".to_owned(), - evals: vec!["inner.eval".to_owned()], - power_stride: 1, - value_term_offsets: vec![0], - shared_terms: Vec::new(), - item_terms: Vec::new(), - }; - let outer_family = SumcheckOutputEvalFamilyPlan { - symbol: "outer.family".to_owned(), - gamma: "outer.gamma".to_owned(), - evals: vec!["outer.eval".to_owned()], - power_stride: 1, - value_term_offsets: Vec::new(), - shared_terms: vec![SumcheckOutputEvalFamilySharedTermPlan { - gamma_power_offset: 0, - factor: "outer.shared.factor".to_owned(), - }], - item_terms: vec![SumcheckOutputEvalFamilyItemTermPlan { - gamma_power_offset: 1, - factors: vec!["factor.expr".to_owned()], - }], - }; - let field_exprs = vec![ - TestFieldExpr { - symbol: "claim.expr".to_owned(), - operands: vec!["outer.family".to_owned()], - }, - TestFieldExpr { - symbol: "factor.expr".to_owned(), - operands: vec!["inner.family".to_owned()], - }, - ]; - let claim_asts = vec![SumcheckOutputClaimAst { - relation: "relation".to_owned(), - polynomial_evals: Vec::new(), - polynomial_eval_operands: Vec::new(), - claim_value: "claim.expr".to_owned(), - }]; - - let claims = match resolve_output_claims( - "test", - &[], - &[inner_family, outer_family], - &field_exprs, - claim_asts, - ) { - Ok(claims) => claims, - Err(err) => panic!("unexpected output claim resolution error: {err:?}"), - }; - let family_symbols = claims[0] - .eval_families - .iter() - .map(|family| family.symbol.as_str()) - .collect::>(); - assert_eq!(family_symbols, vec!["inner.family", "outer.family"]); - } -} - fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) @@ -847,3 +992,143 @@ fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> Em operation_name(operation) )) } + +#[cfg(test)] +mod tests { + use crate::emit::rust::EmitError; + + use super::{ + resolve_output_claims, FieldExprDependencies, SumcheckOutputClaimAst, + SumcheckOutputEvalFamilyItemTermPlan, SumcheckOutputEvalFamilyPlan, + SumcheckOutputEvalFamilySharedTermPlan, SumcheckOutputProductFamilyPlan, + SumcheckOutputProductFamilyTermPlan, + }; + + struct TestFieldExpr { + symbol: String, + operands: Vec, + } + + impl FieldExprDependencies for TestFieldExpr { + fn symbol(&self) -> &str { + &self.symbol + } + + fn operands(&self) -> &[String] { + &self.operands + } + } + + #[test] + fn resolves_output_families_reachable_through_field_expressions() -> Result<(), EmitError> { + let inner_family = SumcheckOutputEvalFamilyPlan { + symbol: "inner.family".to_owned(), + gamma: "inner.gamma".to_owned(), + evals: vec!["inner.eval".to_owned()], + power_stride: 1, + value_term_offsets: vec![0], + shared_terms: Vec::new(), + item_terms: Vec::new(), + }; + let outer_family = SumcheckOutputEvalFamilyPlan { + symbol: "outer.family".to_owned(), + gamma: "outer.gamma".to_owned(), + evals: vec!["outer.eval".to_owned()], + power_stride: 1, + value_term_offsets: Vec::new(), + shared_terms: vec![SumcheckOutputEvalFamilySharedTermPlan { + gamma_power_offset: 0, + factor: "outer.shared.factor".to_owned(), + }], + item_terms: vec![SumcheckOutputEvalFamilyItemTermPlan { + gamma_power_offset: 1, + factors: vec!["factor.expr".to_owned()], + }], + }; + let field_exprs = vec![ + TestFieldExpr { + symbol: "claim.expr".to_owned(), + operands: vec!["outer.family".to_owned()], + }, + TestFieldExpr { + symbol: "factor.expr".to_owned(), + operands: vec!["inner.family".to_owned()], + }, + ]; + let claim_asts = vec![SumcheckOutputClaimAst { + relation: "relation".to_owned(), + polynomial_evals: Vec::new(), + polynomial_eval_operands: Vec::new(), + claim_value: "claim.expr".to_owned(), + }]; + + let claims = resolve_output_claims( + "test", + &[], + &[inner_family, outer_family], + &[], + &field_exprs, + claim_asts, + )?; + let claim = claims + .first() + .ok_or_else(|| EmitError::new("missing resolved output claim"))?; + let family_symbols = claim + .eval_families + .iter() + .map(|family| family.symbol.as_str()) + .collect::>(); + assert_eq!(family_symbols, vec!["inner.family", "outer.family"]); + assert!(claim.product_families.is_empty()); + Ok(()) + } + + #[test] + fn resolves_product_families_reachable_through_field_expressions() -> Result<(), EmitError> { + let product_family = SumcheckOutputProductFamilyPlan { + symbol: "product.family".to_owned(), + gamma: "product.gamma".to_owned(), + terms: vec![SumcheckOutputProductFamilyTermPlan { + gamma_power_offset: 2, + evals: vec!["product.eval".to_owned()], + factors: vec!["product.factor.expr".to_owned()], + }], + }; + let field_exprs = vec![ + TestFieldExpr { + symbol: "claim.expr".to_owned(), + operands: vec!["product.family".to_owned()], + }, + TestFieldExpr { + symbol: "product.factor.expr".to_owned(), + operands: vec!["unrelated.scalar".to_owned()], + }, + ]; + let claim_asts = vec![SumcheckOutputClaimAst { + relation: "relation".to_owned(), + polynomial_evals: Vec::new(), + polynomial_eval_operands: Vec::new(), + claim_value: "claim.expr".to_owned(), + }]; + + let claims = resolve_output_claims( + "test", + &[], + &[], + &[product_family], + &field_exprs, + claim_asts, + )?; + let claim = claims + .first() + .ok_or_else(|| EmitError::new("missing resolved output claim"))?; + assert!(claim.eval_families.is_empty()); + let family_symbols = claim + .product_families + .iter() + .map(|family| family.symbol.as_str()) + .collect::>(); + assert_eq!(family_symbols, vec!["product.family"]); + Ok(()) + } +} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 0632463fe1..10ed8efcf1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -559,6 +559,7 @@ impl Stage3CpuProgram { "stage3", &output_values, &[], + &[], &field_exprs, output_claim_asts, )? @@ -879,12 +880,15 @@ impl Stage3CpuProgram { let point_values = self.point_value_symbols(); super::output_claims::verify_output_claims( "stage3", - &self.output_values, - &[], - &self.output_claims, - &relations, - &field_values, - &point_values, + super::output_claims::OutputClaimVerification { + output_values: &self.output_values, + output_families: &[], + output_product_families: &[], + output_claims: &self.output_claims, + relations: &relations, + field_values: &field_values, + point_values: &point_values, + }, ) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 331ad9c05f..140775726c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -570,6 +570,7 @@ impl Stage4CpuProgram { "stage4", &output_values, &[], + &[], &field_exprs, output_claim_asts, )? @@ -900,12 +901,15 @@ impl Stage4CpuProgram { let point_values = self.point_value_symbols(); super::output_claims::verify_output_claims( "stage4", - &self.output_values, - &[], - &self.output_claims, - &relations, - &field_values, - &point_values, + super::output_claims::OutputClaimVerification { + output_values: &self.output_values, + output_families: &[], + output_product_families: &[], + output_claims: &self.output_claims, + relations: &relations, + field_values: &field_values, + point_values: &point_values, + }, ) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 40f26d3bc9..e6a1fde062 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -570,6 +570,7 @@ impl Stage5CpuProgram { "stage5", &output_values, &[], + &[], &field_exprs, output_claim_asts, )? @@ -901,12 +902,15 @@ impl Stage5CpuProgram { let point_values = self.point_value_symbols(); super::output_claims::verify_output_claims( "stage5", - &self.output_values, - &[], - &self.output_claims, - &relations, - &field_values, - &point_values, + super::output_claims::OutputClaimVerification { + output_values: &self.output_values, + output_families: &[], + output_product_families: &[], + output_claims: &self.output_claims, + relations: &relations, + field_values: &field_values, + point_values: &point_values, + }, ) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 113954290a..ca3420b4c4 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -10,12 +10,13 @@ use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; use super::output_claims::{ - parse_output_eval_family_plan, FieldExprDependencies, + parse_output_eval_family_plan, parse_output_product_family_plan, FieldExprDependencies, StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage6SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage6SumcheckOutputClaimPlan, SumcheckOutputEvalFamilyPlan as Stage6SumcheckOutputEvalFamilyPlan, + SumcheckOutputProductFamilyPlan as Stage6SumcheckOutputProductFamilyPlan, }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; @@ -39,6 +40,7 @@ pub struct Stage6CpuProgram { pub evals: Vec, pub output_values: Vec, pub output_families: Vec, + pub output_product_families: Vec, pub output_claims: Vec, pub point_zeros: Vec, pub point_slices: Vec, @@ -276,6 +278,7 @@ impl Stage6CpuProgram { let mut evals = Vec::new(); let mut output_values = Vec::new(); let mut output_families = Vec::new(); + let mut output_product_families = Vec::new(); let mut output_claim_asts = Vec::new(); let mut point_zeros = Vec::new(); let mut point_slices = Vec::new(); @@ -510,6 +513,9 @@ impl Stage6CpuProgram { "cpu.sumcheck_output_eval_family" => { output_families.push(parse_output_eval_family_plan("stage6", op)?); } + "cpu.sumcheck_output_product_family" => { + output_product_families.push(parse_output_product_family_plan("stage6", op)?); + } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage6SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, @@ -593,6 +599,7 @@ impl Stage6CpuProgram { "stage6", &output_values, &output_families, + &output_product_families, &field_exprs, output_claim_asts, )? @@ -617,6 +624,7 @@ impl Stage6CpuProgram { evals, output_values, output_families, + output_product_families, output_claims, point_zeros, point_slices, @@ -725,6 +733,11 @@ impl Stage6CpuProgram { values.extend(symbols( self.output_families.iter().map(|family| &family.symbol), )); + values.extend(symbols( + self.output_product_families + .iter() + .map(|family| &family.symbol), + )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); values @@ -933,12 +946,15 @@ impl Stage6CpuProgram { let point_values = self.point_value_symbols(); super::output_claims::verify_output_claims( "stage6", - &self.output_values, - &self.output_families, - &self.output_claims, - &relations, - &field_values, - &point_values, + super::output_claims::OutputClaimVerification { + output_values: &self.output_values, + output_families: &self.output_families, + output_product_families: &self.output_product_families, + output_claims: &self.output_claims, + relations: &relations, + field_values: &field_values, + point_values: &point_values, + }, ) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index a91004cbd3..1b8435143b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -10,12 +10,13 @@ use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; use super::output_claims::{ - parse_output_eval_family_plan, FieldExprDependencies, + parse_output_eval_family_plan, parse_output_product_family_plan, FieldExprDependencies, StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage7SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage7SumcheckOutputClaimPlan, SumcheckOutputEvalFamilyPlan as Stage7SumcheckOutputEvalFamilyPlan, + SumcheckOutputProductFamilyPlan as Stage7SumcheckOutputProductFamilyPlan, }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; @@ -39,6 +40,7 @@ pub struct Stage7CpuProgram { pub evals: Vec, pub output_values: Vec, pub output_families: Vec, + pub output_product_families: Vec, pub output_claims: Vec, pub point_zeros: Vec, pub point_slices: Vec, @@ -276,6 +278,7 @@ impl Stage7CpuProgram { let mut evals = Vec::new(); let mut output_values = Vec::new(); let mut output_families = Vec::new(); + let mut output_product_families = Vec::new(); let mut output_claim_asts = Vec::new(); let mut point_zeros = Vec::new(); let mut point_slices = Vec::new(); @@ -510,6 +513,9 @@ impl Stage7CpuProgram { "cpu.sumcheck_output_eval_family" => { output_families.push(parse_output_eval_family_plan("stage7", op)?); } + "cpu.sumcheck_output_product_family" => { + output_product_families.push(parse_output_product_family_plan("stage7", op)?); + } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage7SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, @@ -593,6 +599,7 @@ impl Stage7CpuProgram { "stage7", &output_values, &output_families, + &output_product_families, &field_exprs, output_claim_asts, )? @@ -617,6 +624,7 @@ impl Stage7CpuProgram { evals, output_values, output_families, + output_product_families, output_claims, point_zeros, point_slices, @@ -727,6 +735,11 @@ impl Stage7CpuProgram { values.extend(symbols( self.output_families.iter().map(|family| &family.symbol), )); + values.extend(symbols( + self.output_product_families + .iter() + .map(|family| &family.symbol), + )); values } @@ -930,12 +943,15 @@ impl Stage7CpuProgram { let point_values = self.point_value_symbols(); super::output_claims::verify_output_claims( "stage7", - &self.output_values, - &self.output_families, - &self.output_claims, - &relations, - &field_values, - &point_values, + super::output_claims::OutputClaimVerification { + output_values: &self.output_values, + output_families: &self.output_families, + output_product_families: &self.output_product_families, + output_claims: &self.output_claims, + relations: &relations, + field_values: &field_values, + point_values: &point_values, + }, ) } diff --git a/crates/bolt/src/protocols/jolt/phases/commitment.rs b/crates/bolt/src/protocols/jolt/phases/commitment.rs index c752dbaf69..cb6bed0931 100644 --- a/crates/bolt/src/protocols/jolt/phases/commitment.rs +++ b/crates/bolt/src/protocols/jolt/phases/commitment.rs @@ -972,6 +972,29 @@ pub fn lower_compute_to_cpu<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "compute.sumcheck_output_product_family" => { + let operands = lowered_operands(op, &value_map)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs( + op, + &[ + "term_gamma_power_offsets", + "term_eval_counts", + "term_factor_counts", + "evals", + "factors", + ], + )?; + let operation = context.append_typed_op_with_owned_attrs( + &cpu, + "cpu.sumcheck_output_product_family", + Some(&symbol), + &attrs, + &operands, + &["!cpu.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } "compute.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map)?; let symbol = string_attr(op, "sym_name")?; diff --git a/crates/bolt/src/protocols/jolt/phases/lowering.rs b/crates/bolt/src/protocols/jolt/phases/lowering.rs index 88fda607d4..f85488a7fa 100644 --- a/crates/bolt/src/protocols/jolt/phases/lowering.rs +++ b/crates/bolt/src/protocols/jolt/phases/lowering.rs @@ -479,6 +479,29 @@ pub(super) fn lower_party_to_compute<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "piop.sumcheck_output_product_family" => { + let operands = lowered_operands(op, &value_map, 0)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs( + op, + &[ + "term_gamma_power_offsets", + "term_eval_counts", + "term_factor_counts", + "evals", + "factors", + ], + )?; + let operation = context.append_typed_op_with_owned_attrs( + &compute, + "compute.sumcheck_output_product_family", + Some(&symbol), + &attrs, + &operands, + &["!compute.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } "piop.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; diff --git a/crates/bolt/src/protocols/jolt/phases/stage1.rs b/crates/bolt/src/protocols/jolt/phases/stage1.rs index 54732d93f7..5ebc8c04b9 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage1.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage1.rs @@ -899,6 +899,29 @@ pub fn resolve_compute_kernels<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "compute.sumcheck_output_product_family" => { + let operands = lowered_operands(op, &value_map, 0)?; + let attrs = copy_attrs( + op, + &[ + "term_gamma_power_offsets", + "term_eval_counts", + "term_factor_counts", + "evals", + "factors", + ], + )?; + let symbol = string_attr(op, "sym_name")?; + let operation = context.append_typed_op_with_owned_attrs( + &kernelized, + "compute.sumcheck_output_product_family", + Some(&symbol), + &attrs, + &operands, + &["!compute.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } "compute.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?; diff --git a/crates/bolt/src/protocols/jolt/phases/stage6.rs b/crates/bolt/src/protocols/jolt/phases/stage6.rs index 5ed675e57d..93e5624ce6 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage6.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage6.rs @@ -12,7 +12,8 @@ use super::super::params::JoltProtocolParams; use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type}; use super::sumcheck_output::{ append_structured_polynomial_eval, append_sumcheck_output_claim, - append_sumcheck_output_eval_family, OutputClaimSpec, OutputEvalFamilySpec, + append_sumcheck_output_eval_family, append_sumcheck_output_product_family, OutputClaimSpec, + OutputEvalFamilySpec, OutputProductFamilySpec, OutputProductFamilyTermSpec, StructuredPolynomialPointSpec, StructuredPolynomialSpec, }; @@ -1829,18 +1830,28 @@ fn append_stage6_ram_ra_virtual_output_claim<'c, 'a>( ram.0, inputs.ram_ra_virtual.point, )?; - let ram_product = append_field_product( + let gamma_identity = append_field_one( context, module, - "stage6.ram_ra_virtual.output.product.RamRa", - &output_evals.ram_ra, + "stage6.ram_ra_virtual.output.gamma_identity", )?; - let claim = append_field_mul( + let claim = append_sumcheck_output_product_family( context, module, - "stage6.ram_ra_virtual.output.claim_expr", - eq_cycle, - ram_product, + OutputProductFamilySpec { + symbol: "stage6.ram_ra_virtual.output.family", + }, + gamma_identity, + &[OutputProductFamilyTermSpec { + gamma_power_offset: 0, + evals: output_evals + .ram_ra + .iter() + .enumerate() + .map(|(index, eval)| (format!("stage6.ram_ra_virtual.eval.RamRa_{index}"), *eval)) + .collect(), + factors: vec![("stage6.ram_ra_virtual.output.eq.Cycle".to_owned(), eq_cycle)], + }], )?; append_sumcheck_output_claim( context, @@ -1877,49 +1888,39 @@ fn append_stage6_instruction_ra_virtual_output_claim<'c, 'a>( inputs.instruction_ra_virtual[0].point, )?; let committed_per_virtual = n_committed_per_virtual(params); - let mut virtual_terms = Vec::with_capacity(inputs.instruction_ra_virtual.len()); - for (index, chunk) in output_evals + let mut family_terms = Vec::with_capacity(inputs.instruction_ra_virtual.len()); + for (virtual_index, chunk) in output_evals .instruction_ra .chunks(committed_per_virtual) .enumerate() { - let product = append_field_product( - context, - module, - &format!("stage6.instruction_ra_virtual.output.product.InstructionRa_{index}"), - chunk, - )?; - if index == 0 { - virtual_terms.push(product); - } else { - let gamma_power = append_field_pow( - context, - module, - &format!("stage6.instruction_ra_virtual.output.gamma_pow_{index}"), - gamma, - index, - )?; - virtual_terms.push(append_field_mul( - context, - module, - &format!("stage6.instruction_ra_virtual.output.term.InstructionRa_{index}"), - gamma_power, - product, - )?); - } + family_terms.push(OutputProductFamilyTermSpec { + gamma_power_offset: virtual_index, + evals: chunk + .iter() + .enumerate() + .map(|(chunk_index, eval)| { + let index = virtual_index * committed_per_virtual + chunk_index; + ( + format!("stage6.instruction_ra_virtual.eval.InstructionRa_{index}"), + *eval, + ) + }) + .collect(), + factors: vec![( + "stage6.instruction_ra_virtual.output.eq.Cycle".to_owned(), + eq_cycle, + )], + }); } - let weighted_sum = append_field_sum( + let claim = append_sumcheck_output_product_family( context, module, - "stage6.instruction_ra_virtual.output.weighted_sum", - &virtual_terms, - )?; - let claim = append_field_mul( - context, - module, - "stage6.instruction_ra_virtual.output.claim_expr", - eq_cycle, - weighted_sum, + OutputProductFamilySpec { + symbol: "stage6.instruction_ra_virtual.output.family", + }, + gamma, + &family_terms, )?; append_sumcheck_output_claim( context, @@ -2113,6 +2114,22 @@ fn append_field_zero<'c, 'a>( first_result(op, "field.zero") } +fn append_field_one<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + symbol: &str, +) -> Result, MlirError> { + let op = context.append_typed_op( + module, + "field.one", + Some(symbol), + &[("field", "@bn254_fr")], + &[], + &["!field.scalar"], + )?; + first_result(op, "field.one") +} + fn append_field_binary<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, @@ -2209,30 +2226,6 @@ fn append_field_sum<'c, 'a>( Ok(value) } -fn append_field_product<'c, 'a>( - context: &'c MeliorContext, - module: &'a BoltModule<'c, Protocol>, - symbol_prefix: &str, - factors: &[Value<'c, 'a>], -) -> Result, MlirError> { - let Some((&first, rest)) = factors.split_first() else { - return Err(schema_error(format!( - "{symbol_prefix} requires at least one factor" - ))); - }; - let mut value = first; - for (index, &factor) in rest.iter().enumerate() { - value = append_field_mul( - context, - module, - &format!("{symbol_prefix}.partial{index}"), - value, - factor, - )?; - } - Ok(value) -} - fn append_sumcheck_claim<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, diff --git a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs index a9a72ef4b7..a6da832dc2 100644 --- a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs +++ b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs @@ -60,6 +60,17 @@ pub(crate) struct OutputEvalFamilySpec<'a> { pub(crate) item_term_offsets: &'a [usize], } +pub(crate) struct OutputProductFamilyTermSpec<'c, 'a> { + pub(crate) gamma_power_offset: usize, + pub(crate) evals: Vec<(String, Value<'c, 'a>)>, + pub(crate) factors: Vec<(String, Value<'c, 'a>)>, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct OutputProductFamilySpec<'a> { + pub(crate) symbol: &'a str, +} + pub(crate) fn append_structured_polynomial_eval<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, @@ -167,6 +178,67 @@ pub(crate) fn append_sumcheck_output_eval_family<'c, 'a>( first_result(op, "piop.sumcheck_output_eval_family") } +pub(crate) fn append_sumcheck_output_product_family<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + spec: OutputProductFamilySpec<'_>, + gamma: Value<'c, 'a>, + terms: &[OutputProductFamilyTermSpec<'c, 'a>], +) -> Result, MlirError> { + let term_gamma_power_offsets = terms + .iter() + .map(|term| term.gamma_power_offset) + .collect::>(); + let term_eval_counts = terms + .iter() + .map(|term| term.evals.len()) + .collect::>(); + let term_factor_counts = terms + .iter() + .map(|term| term.factors.len()) + .collect::>(); + let mut operands = Vec::with_capacity( + 1 + term_eval_counts.iter().sum::() + term_factor_counts.iter().sum::(), + ); + operands.push(gamma); + operands.extend( + terms + .iter() + .flat_map(|term| term.evals.iter().map(|(_, value)| *value)), + ); + operands.extend( + terms + .iter() + .flat_map(|term| term.factors.iter().map(|(_, value)| *value)), + ); + let eval_symbols = terms + .iter() + .flat_map(|term| term.evals.iter().map(|(symbol, _)| symbol.as_str())) + .collect::>(); + let factor_symbols = terms + .iter() + .flat_map(|term| term.factors.iter().map(|(symbol, _)| symbol.as_str())) + .collect::>(); + let op = context.append_typed_op( + module, + "piop.sumcheck_output_product_family", + Some(spec.symbol), + &[ + ( + "term_gamma_power_offsets", + &usize_array_attr(&term_gamma_power_offsets), + ), + ("term_eval_counts", &usize_array_attr(&term_eval_counts)), + ("term_factor_counts", &usize_array_attr(&term_factor_counts)), + ("evals", &symbol_array_attr(&eval_symbols)), + ("factors", &symbol_array_attr(&factor_symbols)), + ], + &operands, + &["!field.scalar"], + )?; + first_result(op, "piop.sumcheck_output_product_family") +} + fn first_result<'c, 'a>( operation: melior::ir::operation::OperationRef<'c, 'a>, operation_name: &str, diff --git a/crates/bolt/src/schema.rs b/crates/bolt/src/schema.rs index fb3950fdf4..d9bb0f3366 100644 --- a/crates/bolt/src/schema.rs +++ b/crates/bolt/src/schema.rs @@ -36,6 +36,15 @@ const SUMCHECK_OUTPUT_EVAL_FAMILY_ATTRS: &[&str] = &[ "item_terms", ]; +const SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS: &[&str] = &[ + "sym_name", + "term_gamma_power_offsets", + "term_eval_counts", + "term_factor_counts", + "evals", + "factors", +]; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct SchemaError { message: String, @@ -394,6 +403,11 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_min_shape(operation, 1, 1)?; require_sumcheck_output_eval_family(operation) } + "piop.sumcheck_output_product_family" => { + require_attrs(operation, SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS)?; + require_min_shape(operation, 1, 1)?; + require_sumcheck_output_product_family(operation) + } "piop.sumcheck_output_claim" => { require_attrs( operation, @@ -756,6 +770,11 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_min_shape(operation, 1, 1)?; require_sumcheck_output_eval_family(operation) } + "compute.sumcheck_output_product_family" => { + require_attrs(operation, SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS)?; + require_min_shape(operation, 1, 1)?; + require_sumcheck_output_product_family(operation) + } "compute.sumcheck_output_claim" => { require_attrs( operation, @@ -1101,6 +1120,11 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_min_shape(operation, 1, 1)?; require_sumcheck_output_eval_family(operation) } + "cpu.sumcheck_output_product_family" => { + require_attrs(operation, SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS)?; + require_min_shape(operation, 1, 1)?; + require_sumcheck_output_product_family(operation) + } "cpu.sumcheck_output_claim" => { require_attrs( operation, @@ -1334,6 +1358,82 @@ fn require_sumcheck_output_eval_family(operation: OperationRef<'_, '_>) -> Resul Ok(()) } +fn require_sumcheck_output_product_family( + operation: OperationRef<'_, '_>, +) -> Result<(), SchemaError> { + let evals = symbol_array_attr(operation, "evals")?; + let factors = symbol_array_attr(operation, "factors")?; + let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; + let term_eval_counts = int_array_attr(operation, "term_eval_counts")?; + let term_factor_counts = int_array_attr(operation, "term_factor_counts")?; + if term_eval_counts.len() != term_gamma_power_offsets.len() { + return Err(SchemaError::new(format!( + "{} attr `term_eval_counts` length {} does not match term_gamma_power_offsets length {}", + operation_name(operation), + term_eval_counts.len(), + term_gamma_power_offsets.len() + ))); + } + if term_factor_counts.len() != term_gamma_power_offsets.len() { + return Err(SchemaError::new(format!( + "{} attr `term_factor_counts` length {} does not match term_gamma_power_offsets length {}", + operation_name(operation), + term_factor_counts.len(), + term_gamma_power_offsets.len() + ))); + } + for ((index, eval_count), factor_count) in term_eval_counts + .iter() + .enumerate() + .zip(term_factor_counts.iter()) + { + if *eval_count == 0 && *factor_count == 0 { + return Err(SchemaError::new(format!( + "{} product-family term {index} is empty", + operation_name(operation) + ))); + } + } + let expected_evals: usize = term_eval_counts.iter().sum(); + if evals.len() != expected_evals { + return Err(SchemaError::new(format!( + "{} attr `evals` length {} does not match sum(term_eval_counts) {}", + operation_name(operation), + evals.len(), + expected_evals + ))); + } + let expected_factors: usize = term_factor_counts.iter().sum(); + if factors.len() != expected_factors { + return Err(SchemaError::new(format!( + "{} attr `factors` length {} does not match sum(term_factor_counts) {}", + operation_name(operation), + factors.len(), + expected_factors + ))); + } + let expected_operands = 1 + evals.len() + factors.len(); + if operation.operand_count() != expected_operands { + return Err(SchemaError::new(format!( + "{} expected {expected_operands} operands, got {}", + operation_name(operation), + operation.operand_count() + ))); + } + let expected_symbols = evals.iter().chain(factors.iter()).collect::>(); + for (index, expected) in expected_symbols.iter().enumerate() { + let operand_index = index + 1; + let actual = operand_owner_symbol(operation, operand_index)?; + if &actual != *expected { + return Err(SchemaError::new(format!( + "{} operand {operand_index} expected @{expected}, got @{actual}", + operation_name(operation) + ))); + } + } + Ok(()) +} + fn require_sumcheck_output_claim(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> { let count = int_attr(operation, "count")?; let polynomial_evals = symbol_array_attr(operation, "polynomial_evals")?; diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index c8427eddf8..efc5435d8d 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -920,7 +920,10 @@ fn jolt_stage6_protocol_defines_bytecode_booleanity_and_virtualization_flow() { assert!(text.contains("sym_name = \"stage6.ram_ra_virtual.output.claim\"")); assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.output.claim\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.claim\"")); + assert!(text.contains("sym_name = \"stage6.ram_ra_virtual.output.family\"")); + assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.output.family\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.family\"")); + assert!(text.contains("\"piop.sumcheck_output_product_family\"")); assert!(text.contains("\"piop.sumcheck_output_eval_family\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.eq.RdIncStage5\"")); assert!(!text.contains("kernel = @")); @@ -1503,7 +1506,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(prover_program.transcript_absorb_bytes.is_empty()); assert_eq!(prover_program.opening_inputs.len(), 91); assert!(prover_program.field_exprs.len() > 150); - assert_eq!(prover_program.field_constants.len(), 1); + assert_eq!(prover_program.field_constants.len(), 2); assert!(prover_program.opening_equalities.is_empty()); assert_eq!(prover_program.claims.len(), 6); assert_eq!(prover_program.drivers.len(), 1); @@ -1523,7 +1526,63 @@ fn stage6_rust_targets_extract_and_compile() { assert!(prover_program.output_claims.is_empty()); assert_eq!(verifier_program.output_values.len(), 7); assert_eq!(verifier_program.output_families.len(), 1); + assert_eq!(verifier_program.output_product_families.len(), 2); assert_eq!(verifier_program.output_claims.len(), 4); + let ram_product_families = verifier_program + .output_product_families + .iter() + .filter(|family| family.symbol == "stage6.ram_ra_virtual.output.family") + .collect::>(); + assert_eq!(ram_product_families.len(), 1); + let ram_product_family = ram_product_families[0]; + assert_eq!( + ram_product_family.gamma, + "stage6.ram_ra_virtual.output.gamma_identity" + ); + assert_eq!(ram_product_family.terms.len(), 1); + assert_eq!(ram_product_family.terms[0].gamma_power_offset, 0); + assert_eq!( + ram_product_family.terms[0].evals, + (0..params.ram_d) + .map(|index| format!("stage6.ram_ra_virtual.eval.RamRa_{index}")) + .collect::>() + ); + assert_eq!( + ram_product_family.terms[0].factors, + vec!["stage6.ram_ra_virtual.output.eq.Cycle".to_owned()] + ); + let instruction_product_families = verifier_program + .output_product_families + .iter() + .filter(|family| family.symbol == "stage6.instruction_ra_virtual.output.family") + .collect::>(); + assert_eq!(instruction_product_families.len(), 1); + let instruction_product_family = instruction_product_families[0]; + assert_eq!( + instruction_product_family.gamma, + "stage6.instruction_ra_virtual.gamma" + ); + assert_eq!( + instruction_product_family.terms.len(), + params.instruction_ra_virtual_d + ); + let committed_per_virtual = params.instruction_d / params.instruction_ra_virtual_d; + for (virtual_index, term) in instruction_product_family.terms.iter().enumerate() { + assert_eq!(term.gamma_power_offset, virtual_index); + assert_eq!( + term.evals, + (0..committed_per_virtual) + .map(|chunk_index| { + let index = virtual_index * committed_per_virtual + chunk_index; + format!("stage6.instruction_ra_virtual.eval.InstructionRa_{index}") + }) + .collect::>() + ); + assert_eq!( + term.factors, + vec!["stage6.instruction_ra_virtual.output.eq.Cycle".to_owned()] + ); + } let inc_family = &verifier_program.output_families[0]; assert_eq!( inc_family.symbol, @@ -1564,6 +1623,29 @@ fn stage6_rust_targets_extract_and_compile() { .collect::>(); assert_eq!(inc_claims.len(), 1); assert_eq!(inc_claims[0].eval_families, vec![inc_family.clone()]); + assert!(inc_claims[0].product_families.is_empty()); + let ram_ra_claims = verifier_program + .output_claims + .iter() + .filter(|claim| claim.claim_value == "stage6.ram_ra_virtual.output.family") + .collect::>(); + assert_eq!(ram_ra_claims.len(), 1); + assert!(ram_ra_claims[0].eval_families.is_empty()); + assert_eq!( + ram_ra_claims[0].product_families, + vec![ram_product_family.clone()] + ); + let instruction_ra_claims = verifier_program + .output_claims + .iter() + .filter(|claim| claim.claim_value == "stage6.instruction_ra_virtual.output.family") + .collect::>(); + assert_eq!(instruction_ra_claims.len(), 1); + assert!(instruction_ra_claims[0].eval_families.is_empty()); + assert_eq!( + instruction_ra_claims[0].product_families, + vec![instruction_product_family.clone()] + ); assert_eq!(prover_program.point_zeros.len(), 1); assert_eq!( prover_program.point_slices.len(), @@ -1670,9 +1752,45 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES")); + assert!(verifier_source + .source + .contains("SumcheckOutputProductFamilyPlan")); + assert!(verifier_source + .source + .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILIES")); + assert!(verifier_source + .source + .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES")); + assert!(verifier_source + .source + .contains("stage6.ram_ra_virtual.output.family")); + assert!(verifier_source + .source + .contains("stage6.instruction_ra_virtual.output.family")); assert!(verifier_source .source .contains("stage6.inc_claim_reduction.output.eq.RdIncStage5")); + assert!(!verifier_source + .source + .contains("stage6.ram_ra_virtual.output.product.RamRa")); + assert!(!verifier_source + .source + .contains("stage6.ram_ra_virtual.output.claim_expr")); + assert!(!verifier_source + .source + .contains("stage6.instruction_ra_virtual.output.product.InstructionRa_0")); + assert!(!verifier_source + .source + .contains("stage6.instruction_ra_virtual.output.weighted_sum")); + assert!(!verifier_source + .source + .contains("stage6.instruction_ra_virtual.output.term.InstructionRa_")); + assert!(!verifier_source + .source + .contains("stage6.instruction_ra_virtual.output.gamma_pow_")); + assert!(!verifier_source + .source + .contains("stage6.instruction_ra_virtual.output.claim_expr")); assert!(!verifier_source .source .contains("stage6.inc_claim_reduction.output.term.RamInc")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index d1ee5ee981..7c6d0c7b55 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -652,6 +652,38 @@ macro_rules! define_stage_adapter_impl { }) .collect(), ), + product_families: super::leak_slice( + plan.product_families + .iter() + .map(|family| bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { + symbol: super::leak_str(&family.symbol), + gamma: super::leak_str(&family.gamma), + terms: super::leak_slice( + family + .terms + .iter() + .map(|term| bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { + gamma_power_offset: term.gamma_power_offset, + evals: super::leak_slice( + term + .evals + .iter() + .map(|symbol| super::leak_str(symbol)) + .collect(), + ), + factors: super::leak_slice( + term + .factors + .iter() + .map(|symbol| super::leak_str(symbol)) + .collect(), + ), + }) + .collect(), + ), + }) + .collect(), + ), claim_value: super::leak_str(&plan.claim_value), }) .collect(), diff --git a/crates/jolt-prover/src/stages/stage6.rs b/crates/jolt-prover/src/stages/stage6.rs index 37c8c578a3..dac4f6a1b0 100644 --- a/crates/jolt-prover/src/stages/stage6.rs +++ b/crates/jolt-prover/src/stages/stage6.rs @@ -132,6 +132,7 @@ pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ Stage6FieldConstantPlan { symbol: "stage6.zero", field: "bn254_fr", value: 0 }, + Stage6FieldConstantPlan { symbol: "stage6.ram_ra_virtual.output.gamma_identity", field: "bn254_fr", value: 1 }, ]; pub const STAGE6_FIELD_EXPR_OPERANDS_0: &[&str] = &["stage6.booleanity.gamma"]; diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index a8936e99fd..ca377c3185 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -224,9 +224,9 @@ pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage3StructuredPolynomialEva ]; pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[ - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], claim_value: "stage3.spartan_shift.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], claim_value: "stage3.instruction_input.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], claim_value: "stage3.registers.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], claim_value: "stage3.spartan_shift.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], claim_value: "stage3.instruction_input.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: &[], claim_value: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 5cfdd2682a..328ef88936 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -183,8 +183,8 @@ pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage4StructuredPolynomialEva ]; pub const STAGE4_SUMCHECK_OUTPUT_CLAIMS: &[Stage4SumcheckOutputClaimPlan] = &[ - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], claim_value: "stage4.registers_read_write.output.claim_expr" }, - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], claim_value: "stage4.ram_val_check.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], claim_value: "stage4.registers_read_write.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], claim_value: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 7214c636b7..b97eecb75d 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -294,8 +294,8 @@ pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage5StructuredPolynomialEva ]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIMS: &[Stage5SumcheckOutputClaimPlan] = &[ - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index e22569607d..d11096b1ab 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -290,6 +290,7 @@ pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ Stage6FieldConstantPlan { symbol: "stage6.zero", field: "bn254_fr", value: 0 }, + Stage6FieldConstantPlan { symbol: "stage6.ram_ra_virtual.output.gamma_identity", field: "bn254_fr", value: 1 }, ]; const fn stage6_field_expr(symbol: &'static str, kind: Stage6FieldExprKind, operands: &'static [&'static str]) -> Stage6FieldExprPlan { @@ -354,13 +355,7 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), - stage6_field_expr("stage6.hamming_booleanity.output.square.HammingWeight", Stage6FieldExprKind::Pow(2), &["stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.neg.HammingWeight", Stage6FieldExprKind::Neg, &["stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean", Stage6FieldExprKind::Add, &["stage6.hamming_booleanity.output.square.HammingWeight", "stage6.hamming_booleanity.output.neg.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.hamming_booleanity.output.boolean", "stage6.hamming_booleanity.output.eq.LookupOutput"]), stage6_field_expr("stage6.ram_ra_virtual.output.product.RamRa.partial0", Stage6FieldExprKind::Mul, &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1"]), stage6_field_expr("stage6.ram_ra_virtual.output.product.RamRa.partial1", Stage6FieldExprKind::Mul, &["stage6.ram_ra_virtual.output.product.RamRa.partial0", "stage6.ram_ra_virtual.eval.RamRa_2"]), stage6_field_expr("stage6.ram_ra_virtual.output.product.RamRa.partial2", Stage6FieldExprKind::Mul, &["stage6.ram_ra_virtual.output.product.RamRa.partial1", "stage6.ram_ra_virtual.eval.RamRa_3"]), stage6_field_expr("stage6.ram_ra_virtual.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.ram_ra_virtual.output.eq.Cycle", "stage6.ram_ra_virtual.output.product.RamRa.partial2"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_1", "stage6.instruction_ra_virtual.output.product.InstructionRa_1.partial2"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_10"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_11"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_2", "stage6.instruction_ra_virtual.output.product.InstructionRa_2.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_14"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_15"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_3", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.output.product.InstructionRa_3.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_18"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_19"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_4", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.output.product.InstructionRa_4.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_22"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_23"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_5", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.output.product.InstructionRa_5.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_26"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_27"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_6", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.output.product.InstructionRa_6.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial0", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial1", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial0", "stage6.instruction_ra_virtual.eval.InstructionRa_30"]), stage6_field_expr("stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial2", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial1", "stage6.instruction_ra_virtual.eval.InstructionRa_31"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term.InstructionRa_7", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.output.product.InstructionRa_7.partial2"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial0", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.product.InstructionRa_0.partial2", "stage6.instruction_ra_virtual.output.term.InstructionRa_1"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial0", "stage6.instruction_ra_virtual.output.term.InstructionRa_2"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial1", "stage6.instruction_ra_virtual.output.term.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial2", "stage6.instruction_ra_virtual.output.term.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial3", "stage6.instruction_ra_virtual.output.term.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial4", "stage6.instruction_ra_virtual.output.term.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.output.weighted_sum.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.output.weighted_sum.partial5", "stage6.instruction_ra_virtual.output.term.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.output.eq.Cycle", "stage6.instruction_ra_virtual.output.weighted_sum.partial6"]), + stage6_field_expr("stage6.hamming_booleanity.output.square.HammingWeight", Stage6FieldExprKind::Pow(2), &["stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.neg.HammingWeight", Stage6FieldExprKind::Neg, &["stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean", Stage6FieldExprKind::Add, &["stage6.hamming_booleanity.output.square.HammingWeight", "stage6.hamming_booleanity.output.neg.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.hamming_booleanity.output.boolean", "stage6.hamming_booleanity.output.eq.LookupOutput"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -619,10 +614,49 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage6StructuredPolynomialEva Stage6StructuredPolynomialEvalPlan { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.ram_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.ram_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERM_0_FACTORS }, +]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: "stage6.ram_ra_virtual.output.gamma_identity", terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERMS }, +]; + pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.instruction_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 3, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 4, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 5, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 6, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_FACTORS }, +]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: "stage6.instruction_ra_virtual.gamma", terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, +]; + pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage2.ram_read_write.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.ram_val_check.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, @@ -646,10 +680,10 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES: &[bolt_verifier_runtime::Sumc ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[ - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], claim_value: "stage6.hamming_booleanity.output.claim_expr" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], claim_value: "stage6.ram_ra_virtual.output.claim_expr" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], claim_value: "stage6.instruction_ra_virtual.output.claim_expr" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES, claim_value: "stage6.inc_claim_reduction.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], claim_value: "stage6.hamming_booleanity.output.claim_expr" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILIES, claim_value: "stage6.ram_ra_virtual.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, claim_value: "stage6.instruction_ra_virtual.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES, product_families: &[], claim_value: "stage6.inc_claim_reduction.output.family" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index cf0f4526fd..85902260e4 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -288,7 +288,7 @@ pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES: &[bolt_verifier_runtime::Sumc ]; pub const STAGE7_SUMCHECK_OUTPUT_CLAIMS: &[Stage7SumcheckOutputClaimPlan] = &[ - Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES, claim_value: "stage7.hamming_weight_claim_reduction.output.family" }, + Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES, product_families: &[], claim_value: "stage7.hamming_weight_claim_reduction.output.family" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ From 05f4e4a05454549d65556f5f6db101ff3af7d581 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 17:54:28 -0600 Subject: [PATCH 036/171] refactor(bolt): add output function families Add typed output function-family plans for verifier output claims across the Bolt IR, emitter, runtime, and equivalence adapter. Cut Stage 6 hamming Booleanity output over to a BooleanZero function-family plan and regenerate the checked-in role artifacts. --- crates/bolt-verifier-runtime/src/lib.rs | 59 ++++ crates/bolt/irdl/compute.mlir | 19 ++ crates/bolt/irdl/cpu.mlir | 19 ++ crates/bolt/irdl/piop.mlir | 19 ++ .../protocols/jolt/emit/rust/output_claims.rs | 319 +++++++++++++++++- .../src/protocols/jolt/emit/rust/stage3.rs | 2 + .../src/protocols/jolt/emit/rust/stage4.rs | 2 + .../src/protocols/jolt/emit/rust/stage5.rs | 2 + .../src/protocols/jolt/emit/rust/stage6.rs | 17 +- .../src/protocols/jolt/emit/rust/stage7.rs | 17 +- .../src/protocols/jolt/phases/commitment.rs | 23 ++ .../src/protocols/jolt/phases/lowering.rs | 23 ++ .../bolt/src/protocols/jolt/phases/stage1.rs | 23 ++ .../bolt/src/protocols/jolt/phases/stage6.rs | 64 ++-- .../protocols/jolt/phases/sumcheck_output.rs | 74 ++++ crates/bolt/src/schema.rs | 123 +++++++ crates/bolt/tests/commitment_ir.rs | 63 +++- crates/jolt-equivalence/src/plan_adapters.rs | 40 +++ crates/jolt-prover/src/stages/stage6.rs | 1 + crates/jolt-verifier/src/stages/stage3.rs | 6 +- crates/jolt-verifier/src/stages/stage4.rs | 4 +- crates/jolt-verifier/src/stages/stage5.rs | 4 +- crates/jolt-verifier/src/stages/stage6.rs | 18 +- crates/jolt-verifier/src/stages/stage7.rs | 2 +- 24 files changed, 878 insertions(+), 65 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 95a83e2fd1..9a5bc7c66e 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -392,12 +392,33 @@ pub struct SumcheckOutputProductFamilyPlan { pub terms: &'static [SumcheckOutputProductFamilyTermPlan], } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SumcheckOutputFunctionKind { + BooleanZero, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct SumcheckOutputFunctionFamilyTermPlan { + pub gamma_power_offset: usize, + pub function: SumcheckOutputFunctionKind, + pub eval: &'static str, + pub factors: &'static [&'static str], +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct SumcheckOutputFunctionFamilyPlan { + pub symbol: &'static str, + pub gamma: &'static str, + pub terms: &'static [SumcheckOutputFunctionFamilyTermPlan], +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct SumcheckOutputClaimPlan { pub relation: R, pub polynomial_evals: &'static [StructuredPolynomialEvalPlan], pub eval_families: &'static [SumcheckOutputEvalFamilyPlan], pub product_families: &'static [SumcheckOutputProductFamilyPlan], + pub function_families: &'static [SumcheckOutputFunctionFamilyPlan], pub claim_value: &'static str, } @@ -1213,6 +1234,10 @@ pub fn evaluate_sumcheck_output_claim( let value = evaluate_sumcheck_output_eval_family(family, store, &scratch)?; scratch.insert(family.symbol, value); } + for family in plan.function_families { + let value = evaluate_sumcheck_output_function_family(family, store, &scratch)?; + scratch.insert(family.symbol, value); + } for family in plan.product_families { let value = evaluate_sumcheck_output_product_family(family, store, &scratch)?; scratch.insert(family.symbol, value); @@ -1322,6 +1347,40 @@ fn evaluate_sumcheck_output_product_family( Ok(result) } +fn evaluate_sumcheck_output_function_family( + family: &SumcheckOutputFunctionFamilyPlan, + store: &ValueStore, + scratch: &ScratchScalars, +) -> Result { + let gamma = scratch + .scalar_or(store, family.gamma) + .ok_or(RuntimePlanError::MissingValue { + symbol: family.gamma, + })?; + let mut result = Fr::from_u64(0); + for term in family.terms { + let eval = scratch + .scalar_or(store, term.eval) + .ok_or(RuntimePlanError::MissingValue { symbol: term.eval })?; + let mut product = pow_field(gamma, term.gamma_power_offset) + * evaluate_output_function(term.function, eval); + for &symbol in term.factors { + let value = scratch + .scalar_or(store, symbol) + .ok_or(RuntimePlanError::MissingValue { symbol })?; + product *= value; + } + result += product; + } + Ok(result) +} + +fn evaluate_output_function(function: SumcheckOutputFunctionKind, eval: Fr) -> Fr { + match function { + SumcheckOutputFunctionKind::BooleanZero => eval * eval - eval, + } +} + fn evaluate_structured_polynomial_point( plan: StructuredPolynomialPointPlan, raw_point: &[Fr], diff --git a/crates/bolt/irdl/compute.mlir b/crates/bolt/irdl/compute.mlir index 48030710bf..89f3425dc3 100644 --- a/crates/bolt/irdl/compute.mlir +++ b/crates/bolt/irdl/compute.mlir @@ -736,6 +736,25 @@ irdl.dialect @compute { irdl.operands(gamma: %value, inputs: variadic %value) irdl.results(value: %value) } + irdl.operation @sumcheck_output_function_family { + %value = irdl.parametric @compute::@field_value<> + %sym = irdl.any + %term_gamma_power_offsets = irdl.any + %term_functions = irdl.any + %term_factor_counts = irdl.any + %evals = irdl.any + %factors = irdl.any + irdl.attributes { + "sym_name" = %sym, + "term_gamma_power_offsets" = %term_gamma_power_offsets, + "term_functions" = %term_functions, + "term_factor_counts" = %term_factor_counts, + "evals" = %evals, + "factors" = %factors + } + irdl.operands(gamma: %value, inputs: variadic %value) + irdl.results(value: %value) + } irdl.operation @sumcheck_output_claim { %value = irdl.parametric @compute::@field_value<> %sym = irdl.any diff --git a/crates/bolt/irdl/cpu.mlir b/crates/bolt/irdl/cpu.mlir index ae28f315fb..04b0d3e534 100644 --- a/crates/bolt/irdl/cpu.mlir +++ b/crates/bolt/irdl/cpu.mlir @@ -666,6 +666,25 @@ irdl.dialect @cpu { irdl.operands(gamma: %value, inputs: variadic %value) irdl.results(value: %value) } + irdl.operation @sumcheck_output_function_family { + %value = irdl.parametric @cpu::@field_value<> + %sym = irdl.any + %term_gamma_power_offsets = irdl.any + %term_functions = irdl.any + %term_factor_counts = irdl.any + %evals = irdl.any + %factors = irdl.any + irdl.attributes { + "sym_name" = %sym, + "term_gamma_power_offsets" = %term_gamma_power_offsets, + "term_functions" = %term_functions, + "term_factor_counts" = %term_factor_counts, + "evals" = %evals, + "factors" = %factors + } + irdl.operands(gamma: %value, inputs: variadic %value) + irdl.results(value: %value) + } irdl.operation @sumcheck_output_claim { %value = irdl.parametric @cpu::@field_value<> %sym = irdl.any diff --git a/crates/bolt/irdl/piop.mlir b/crates/bolt/irdl/piop.mlir index c1b320732a..7c24891c65 100644 --- a/crates/bolt/irdl/piop.mlir +++ b/crates/bolt/irdl/piop.mlir @@ -284,6 +284,25 @@ irdl.dialect @piop { irdl.operands(gamma: %value, inputs: variadic %value) irdl.results(value: %value) } + irdl.operation @sumcheck_output_function_family { + %value = irdl.parametric @field::@scalar<> + %sym = irdl.any + %term_gamma_power_offsets = irdl.any + %term_functions = irdl.any + %term_factor_counts = irdl.any + %evals = irdl.any + %factors = irdl.any + irdl.attributes { + "sym_name" = %sym, + "term_gamma_power_offsets" = %term_gamma_power_offsets, + "term_functions" = %term_functions, + "term_factor_counts" = %term_factor_counts, + "evals" = %evals, + "factors" = %factors + } + irdl.operands(gamma: %value, inputs: variadic %value) + irdl.results(value: %value) + } irdl.operation @sumcheck_output_claim { %value = irdl.parametric @field::@scalar<> %sym = irdl.any diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index 584fd4749f..33e90b9d73 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -60,12 +60,28 @@ pub struct SumcheckOutputProductFamilyPlan { pub terms: Vec, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputFunctionFamilyTermPlan { + pub gamma_power_offset: usize, + pub function: String, + pub eval: String, + pub factors: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputFunctionFamilyPlan { + pub symbol: String, + pub gamma: String, + pub terms: Vec, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct SumcheckOutputClaimPlan { pub relation: String, pub polynomial_evals: Vec, pub eval_families: Vec, pub product_families: Vec, + pub function_families: Vec, pub claim_value: String, } @@ -229,6 +245,79 @@ pub fn parse_output_product_family_plan( }) } +pub fn parse_output_function_family_plan( + stage: &str, + operation: OperationRef<'_, '_>, +) -> Result { + let symbol = string_attr(operation, "sym_name")?; + let evals = symbol_array_attr(operation, "evals")?; + let factors = symbol_array_attr(operation, "factors")?; + let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; + let term_functions = string_array_attr(operation, "term_functions")?; + let term_factor_counts = int_array_attr(operation, "term_factor_counts")?; + verify_count( + "output function family term functions", + &symbol, + term_gamma_power_offsets.len(), + term_functions.len(), + )?; + verify_count( + "output function family term factor counts", + &symbol, + term_gamma_power_offsets.len(), + term_factor_counts.len(), + )?; + verify_count( + "output function family evals", + &symbol, + term_gamma_power_offsets.len(), + evals.len(), + )?; + verify_count( + "output function family factors", + &symbol, + term_factor_counts.iter().sum(), + factors.len(), + )?; + let gamma = operand_symbol(operation, 0)?; + let eval_end = 1 + evals.len(); + let eval_operands = operand_symbols(operation, 1, eval_end)?; + if evals != eval_operands { + return Err(EmitError::new(format!( + "{stage} output function family @{symbol} evals do not match operands" + ))); + } + let factor_operands = operand_symbols(operation, eval_end, operation.operand_count())?; + if factors != factor_operands { + return Err(EmitError::new(format!( + "{stage} output function family @{symbol} factors do not match operands" + ))); + } + let mut factor_offset = 0; + let mut terms = Vec::with_capacity(term_gamma_power_offsets.len()); + for (((gamma_power_offset, function), eval), factor_count) in term_gamma_power_offsets + .into_iter() + .zip(term_functions) + .zip(evals) + .zip(term_factor_counts) + { + require_output_function(stage, &symbol, &function)?; + let factor_end = factor_offset + factor_count; + terms.push(SumcheckOutputFunctionFamilyTermPlan { + gamma_power_offset, + function, + eval, + factors: factors[factor_offset..factor_end].to_vec(), + }); + factor_offset = factor_end; + } + Ok(SumcheckOutputFunctionFamilyPlan { + symbol, + gamma, + terms, + }) +} + pub trait FieldExprDependencies { fn symbol(&self) -> &str; fn operands(&self) -> &[String]; @@ -239,6 +328,7 @@ pub fn resolve_output_claims( output_values: &[StructuredPolynomialEvalPlan], output_families: &[SumcheckOutputEvalFamilyPlan], output_product_families: &[SumcheckOutputProductFamilyPlan], + output_function_families: &[SumcheckOutputFunctionFamilyPlan], field_exprs: &[T], claim_asts: Vec, ) -> Result, EmitError> @@ -257,6 +347,10 @@ where .iter() .map(|family| (family.symbol.as_str(), family)) .collect(); + let output_function_families_by_symbol: BTreeMap<_, _> = output_function_families + .iter() + .map(|family| (family.symbol.as_str(), family)) + .collect(); let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs .iter() .map(|expr| (expr.symbol(), expr)) @@ -295,17 +389,23 @@ where let family_symbols = output_family_dependency_closure( &output_families_by_symbol, &output_product_families_by_symbol, + &output_function_families_by_symbol, &field_exprs_by_symbol, std::iter::once(claim.claim_value.as_str()), ); let eval_families = output_families .iter() - .filter(|family| family_symbols.eval_families.contains(&family.symbol)) + .filter(|family| family_symbols.eval.contains(&family.symbol)) .cloned() .collect(); let product_families = output_product_families .iter() - .filter(|family| family_symbols.product_families.contains(&family.symbol)) + .filter(|family| family_symbols.product.contains(&family.symbol)) + .cloned() + .collect(); + let function_families = output_function_families + .iter() + .filter(|family| family_symbols.function.contains(&family.symbol)) .cloned() .collect(); Ok(SumcheckOutputClaimPlan { @@ -313,6 +413,7 @@ where polynomial_evals, eval_families, product_families, + function_families, claim_value: claim.claim_value, }) }) @@ -320,13 +421,15 @@ where } struct OutputFamilyDependencyClosure { - eval_families: BTreeSet, - product_families: BTreeSet, + eval: BTreeSet, + product: BTreeSet, + function: BTreeSet, } fn output_family_dependency_closure<'a, T>( output_families_by_symbol: &BTreeMap<&str, &SumcheckOutputEvalFamilyPlan>, output_product_families_by_symbol: &BTreeMap<&str, &SumcheckOutputProductFamilyPlan>, + output_function_families_by_symbol: &BTreeMap<&str, &SumcheckOutputFunctionFamilyPlan>, field_exprs_by_symbol: &BTreeMap<&str, &T>, roots: impl Iterator, ) -> OutputFamilyDependencyClosure @@ -336,6 +439,7 @@ where let mut visited = BTreeSet::new(); let mut eval_families = BTreeSet::new(); let mut product_families = BTreeSet::new(); + let mut function_families = BTreeSet::new(); let mut stack = roots.map(str::to_owned).collect::>(); while let Some(symbol) = stack.pop() { if !visited.insert(symbol.clone()) { @@ -361,13 +465,22 @@ where stack.extend(term.factors.iter().cloned()); } } + if let Some(family) = output_function_families_by_symbol.get(symbol.as_str()) { + let _inserted = function_families.insert(family.symbol.clone()); + stack.push(family.gamma.clone()); + for term in &family.terms { + stack.push(term.eval.clone()); + stack.extend(term.factors.iter().cloned()); + } + } if let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) { stack.extend(expr.operands().iter().cloned()); } } OutputFamilyDependencyClosure { - eval_families, - product_families, + eval: eval_families, + product: product_families, + function: function_families, } } @@ -396,6 +509,7 @@ pub struct OutputClaimVerification<'a> { pub output_values: &'a [StructuredPolynomialEvalPlan], pub output_families: &'a [SumcheckOutputEvalFamilyPlan], pub output_product_families: &'a [SumcheckOutputProductFamilyPlan], + pub output_function_families: &'a [SumcheckOutputFunctionFamilyPlan], pub output_claims: &'a [SumcheckOutputClaimPlan], pub relations: &'a BTreeSet, pub field_values: &'a BTreeSet, @@ -410,6 +524,7 @@ pub fn verify_output_claims( output_values, output_families, output_product_families, + output_function_families, output_claims, relations, field_values, @@ -512,6 +627,31 @@ pub fn verify_output_claims( } } } + for family in output_function_families { + if !field_values.contains(&family.gamma) { + return Err(EmitError::new(format!( + "{stage} output function family @{} references missing gamma @{}", + family.symbol, family.gamma + ))); + } + for term in &family.terms { + require_output_function(stage, &family.symbol, &term.function)?; + if !field_values.contains(&term.eval) { + return Err(EmitError::new(format!( + "{stage} output function family @{} references missing eval @{}", + family.symbol, term.eval + ))); + } + for factor in &term.factors { + if !field_values.contains(factor) { + return Err(EmitError::new(format!( + "{stage} output function family @{} references missing factor @{}", + family.symbol, factor + ))); + } + } + } + } for claim in output_claims { if !relations.contains(&claim.relation) { return Err(EmitError::new(format!( @@ -563,8 +703,10 @@ pub fn emit_verifier_output_claim_constants( ); let eval_families = emit_eval_family_constants(&mut source, stage_type, index, claim); let product_families = emit_product_family_constants(&mut source, stage_type, index, claim); + let function_families = + emit_function_family_constants(&mut source, stage_type, index, claim)?; claims.push(format!( - " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, product_families: {product_families}, claim_value: {} }},", + " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, product_families: {product_families}, function_families: {function_families}, claim_value: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, rust_str(&claim.claim_value) )); @@ -725,6 +867,82 @@ fn emit_product_family_constants( families_name } +fn emit_function_family_constants( + source: &mut String, + stage_type: &str, + claim_index: usize, + claim: &SumcheckOutputClaimPlan, +) -> Result { + if claim.function_families.is_empty() { + return Ok("&[]".to_owned()); + } + let upper_stage = stage_type.to_ascii_uppercase(); + let mut family_rows = Vec::new(); + for (family_index, family) in claim.function_families.iter().enumerate() { + let prefix = format!( + "{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_FUNCTION_FAMILY_{family_index}" + ); + let mut term_rows = Vec::new(); + for (term_index, term) in family.terms.iter().enumerate() { + let factors_name = format!("{prefix}_TERM_{term_index}_FACTORS"); + let factors = rust_str_array(&term.factors); + push_format( + source, + format_args!("pub const {factors_name}: &[&str] = &[{factors}];\n"), + ); + term_rows.push(format!( + " bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan {{ gamma_power_offset: {}, function: {}, eval: {}, factors: {factors_name} }},", + term.gamma_power_offset, + output_function_kind_expr(&term.function)?, + rust_str(&term.eval) + )); + } + let terms_name = format!("{prefix}_TERMS"); + let terms = term_rows.join("\n"); + push_format( + source, + format_args!( + "pub const {terms_name}: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan] = &[\n{terms}\n];\n" + ), + ); + family_rows.push(format!( + " bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan {{ symbol: {}, gamma: {}, terms: {terms_name} }},", + rust_str(&family.symbol), + rust_str(&family.gamma), + )); + } + let families_name = + format!("{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_FUNCTION_FAMILIES"); + let families = family_rows.join("\n"); + push_format( + source, + format_args!( + "pub const {families_name}: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan] = &[\n{families}\n];\n\n" + ), + ); + Ok(families_name) +} + +fn output_function_kind_expr(function: &str) -> Result<&'static str, EmitError> { + require_output_function("verifier output", "generated constants", function)?; + match function { + "boolean_zero" => Ok("bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero"), + _ => Err(EmitError::new(format!( + "unsupported output function `{function}`" + ))), + } +} + +fn require_output_function(stage: &str, family: &str, function: &str) -> Result<(), EmitError> { + if function == "boolean_zero" { + Ok(()) + } else { + Err(EmitError::new(format!( + "{stage} output function family @{family} has unsupported function `{function}`" + ))) + } +} + fn field_expr_dependency_closure<'a, T>( field_exprs_by_symbol: &BTreeMap<&str, &T>, roots: impl Iterator, @@ -923,6 +1141,34 @@ fn parse_symbol_array(attribute: &str) -> Option> { .collect() } +fn string_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, EmitError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "string array"))?; + parse_string_array(&attribute).ok_or_else(|| attr_error(operation, attr, "string array")) +} + +fn parse_string_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| { + item.trim() + .strip_prefix('"')? + .strip_suffix('"') + .map(ToOwned::to_owned) + }) + .collect() +} + fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) @@ -1000,7 +1246,8 @@ mod tests { use super::{ resolve_output_claims, FieldExprDependencies, SumcheckOutputClaimAst, SumcheckOutputEvalFamilyItemTermPlan, SumcheckOutputEvalFamilyPlan, - SumcheckOutputEvalFamilySharedTermPlan, SumcheckOutputProductFamilyPlan, + SumcheckOutputEvalFamilySharedTermPlan, SumcheckOutputFunctionFamilyPlan, + SumcheckOutputFunctionFamilyTermPlan, SumcheckOutputProductFamilyPlan, SumcheckOutputProductFamilyTermPlan, }; @@ -1067,6 +1314,7 @@ mod tests { &[], &[inner_family, outer_family], &[], + &[], &field_exprs, claim_asts, )?; @@ -1080,6 +1328,7 @@ mod tests { .collect::>(); assert_eq!(family_symbols, vec!["inner.family", "outer.family"]); assert!(claim.product_families.is_empty()); + assert!(claim.function_families.is_empty()); Ok(()) } @@ -1116,6 +1365,7 @@ mod tests { &[], &[], &[product_family], + &[], &field_exprs, claim_asts, )?; @@ -1129,6 +1379,59 @@ mod tests { .map(|family| family.symbol.as_str()) .collect::>(); assert_eq!(family_symbols, vec!["product.family"]); + assert!(claim.function_families.is_empty()); + Ok(()) + } + + #[test] + fn resolves_function_families_reachable_through_field_expressions() -> Result<(), EmitError> { + let function_family = SumcheckOutputFunctionFamilyPlan { + symbol: "function.family".to_owned(), + gamma: "function.gamma".to_owned(), + terms: vec![SumcheckOutputFunctionFamilyTermPlan { + gamma_power_offset: 0, + function: "boolean_zero".to_owned(), + eval: "function.eval".to_owned(), + factors: vec!["function.factor.expr".to_owned()], + }], + }; + let field_exprs = vec![ + TestFieldExpr { + symbol: "claim.expr".to_owned(), + operands: vec!["function.family".to_owned()], + }, + TestFieldExpr { + symbol: "function.factor.expr".to_owned(), + operands: vec!["unrelated.scalar".to_owned()], + }, + ]; + let claim_asts = vec![SumcheckOutputClaimAst { + relation: "relation".to_owned(), + polynomial_evals: Vec::new(), + polynomial_eval_operands: Vec::new(), + claim_value: "claim.expr".to_owned(), + }]; + + let claims = resolve_output_claims( + "test", + &[], + &[], + &[], + &[function_family], + &field_exprs, + claim_asts, + )?; + let claim = claims + .first() + .ok_or_else(|| EmitError::new("missing resolved output claim"))?; + assert!(claim.eval_families.is_empty()); + assert!(claim.product_families.is_empty()); + let family_symbols = claim + .function_families + .iter() + .map(|family| family.symbol.as_str()) + .collect::>(); + assert_eq!(family_symbols, vec!["function.family"]); Ok(()) } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 10ed8efcf1..aaa71e5874 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -560,6 +560,7 @@ impl Stage3CpuProgram { &output_values, &[], &[], + &[], &field_exprs, output_claim_asts, )? @@ -884,6 +885,7 @@ impl Stage3CpuProgram { output_values: &self.output_values, output_families: &[], output_product_families: &[], + output_function_families: &[], output_claims: &self.output_claims, relations: &relations, field_values: &field_values, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 140775726c..d6853e9ea5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -571,6 +571,7 @@ impl Stage4CpuProgram { &output_values, &[], &[], + &[], &field_exprs, output_claim_asts, )? @@ -905,6 +906,7 @@ impl Stage4CpuProgram { output_values: &self.output_values, output_families: &[], output_product_families: &[], + output_function_families: &[], output_claims: &self.output_claims, relations: &relations, field_values: &field_values, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index e6a1fde062..4b394ed94d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -571,6 +571,7 @@ impl Stage5CpuProgram { &output_values, &[], &[], + &[], &field_exprs, output_claim_asts, )? @@ -906,6 +907,7 @@ impl Stage5CpuProgram { output_values: &self.output_values, output_families: &[], output_product_families: &[], + output_function_families: &[], output_claims: &self.output_claims, relations: &relations, field_values: &field_values, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index ca3420b4c4..b74ecbd848 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -10,12 +10,14 @@ use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; use super::output_claims::{ - parse_output_eval_family_plan, parse_output_product_family_plan, FieldExprDependencies, + parse_output_eval_family_plan, parse_output_function_family_plan, + parse_output_product_family_plan, FieldExprDependencies, StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage6SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage6SumcheckOutputClaimPlan, SumcheckOutputEvalFamilyPlan as Stage6SumcheckOutputEvalFamilyPlan, + SumcheckOutputFunctionFamilyPlan as Stage6SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan as Stage6SumcheckOutputProductFamilyPlan, }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; @@ -41,6 +43,7 @@ pub struct Stage6CpuProgram { pub output_values: Vec, pub output_families: Vec, pub output_product_families: Vec, + pub output_function_families: Vec, pub output_claims: Vec, pub point_zeros: Vec, pub point_slices: Vec, @@ -279,6 +282,7 @@ impl Stage6CpuProgram { let mut output_values = Vec::new(); let mut output_families = Vec::new(); let mut output_product_families = Vec::new(); + let mut output_function_families = Vec::new(); let mut output_claim_asts = Vec::new(); let mut point_zeros = Vec::new(); let mut point_slices = Vec::new(); @@ -516,6 +520,9 @@ impl Stage6CpuProgram { "cpu.sumcheck_output_product_family" => { output_product_families.push(parse_output_product_family_plan("stage6", op)?); } + "cpu.sumcheck_output_function_family" => { + output_function_families.push(parse_output_function_family_plan("stage6", op)?); + } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage6SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, @@ -600,6 +607,7 @@ impl Stage6CpuProgram { &output_values, &output_families, &output_product_families, + &output_function_families, &field_exprs, output_claim_asts, )? @@ -625,6 +633,7 @@ impl Stage6CpuProgram { output_values, output_families, output_product_families, + output_function_families, output_claims, point_zeros, point_slices, @@ -738,6 +747,11 @@ impl Stage6CpuProgram { .iter() .map(|family| &family.symbol), )); + values.extend(symbols( + self.output_function_families + .iter() + .map(|family| &family.symbol), + )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); values @@ -950,6 +964,7 @@ impl Stage6CpuProgram { output_values: &self.output_values, output_families: &self.output_families, output_product_families: &self.output_product_families, + output_function_families: &self.output_function_families, output_claims: &self.output_claims, relations: &relations, field_values: &field_values, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 1b8435143b..e9542d03ae 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -10,12 +10,14 @@ use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; use super::output_claims::{ - parse_output_eval_family_plan, parse_output_product_family_plan, FieldExprDependencies, + parse_output_eval_family_plan, parse_output_function_family_plan, + parse_output_product_family_plan, FieldExprDependencies, StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage7SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage7SumcheckOutputClaimPlan, SumcheckOutputEvalFamilyPlan as Stage7SumcheckOutputEvalFamilyPlan, + SumcheckOutputFunctionFamilyPlan as Stage7SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan as Stage7SumcheckOutputProductFamilyPlan, }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; @@ -41,6 +43,7 @@ pub struct Stage7CpuProgram { pub output_values: Vec, pub output_families: Vec, pub output_product_families: Vec, + pub output_function_families: Vec, pub output_claims: Vec, pub point_zeros: Vec, pub point_slices: Vec, @@ -279,6 +282,7 @@ impl Stage7CpuProgram { let mut output_values = Vec::new(); let mut output_families = Vec::new(); let mut output_product_families = Vec::new(); + let mut output_function_families = Vec::new(); let mut output_claim_asts = Vec::new(); let mut point_zeros = Vec::new(); let mut point_slices = Vec::new(); @@ -516,6 +520,9 @@ impl Stage7CpuProgram { "cpu.sumcheck_output_product_family" => { output_product_families.push(parse_output_product_family_plan("stage7", op)?); } + "cpu.sumcheck_output_function_family" => { + output_function_families.push(parse_output_function_family_plan("stage7", op)?); + } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage7SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, @@ -600,6 +607,7 @@ impl Stage7CpuProgram { &output_values, &output_families, &output_product_families, + &output_function_families, &field_exprs, output_claim_asts, )? @@ -625,6 +633,7 @@ impl Stage7CpuProgram { output_values, output_families, output_product_families, + output_function_families, output_claims, point_zeros, point_slices, @@ -740,6 +749,11 @@ impl Stage7CpuProgram { .iter() .map(|family| &family.symbol), )); + values.extend(symbols( + self.output_function_families + .iter() + .map(|family| &family.symbol), + )); values } @@ -947,6 +961,7 @@ impl Stage7CpuProgram { output_values: &self.output_values, output_families: &self.output_families, output_product_families: &self.output_product_families, + output_function_families: &self.output_function_families, output_claims: &self.output_claims, relations: &relations, field_values: &field_values, diff --git a/crates/bolt/src/protocols/jolt/phases/commitment.rs b/crates/bolt/src/protocols/jolt/phases/commitment.rs index cb6bed0931..901edba7d7 100644 --- a/crates/bolt/src/protocols/jolt/phases/commitment.rs +++ b/crates/bolt/src/protocols/jolt/phases/commitment.rs @@ -995,6 +995,29 @@ pub fn lower_compute_to_cpu<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "compute.sumcheck_output_function_family" => { + let operands = lowered_operands(op, &value_map)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs( + op, + &[ + "term_gamma_power_offsets", + "term_functions", + "term_factor_counts", + "evals", + "factors", + ], + )?; + let operation = context.append_typed_op_with_owned_attrs( + &cpu, + "cpu.sumcheck_output_function_family", + Some(&symbol), + &attrs, + &operands, + &["!cpu.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } "compute.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map)?; let symbol = string_attr(op, "sym_name")?; diff --git a/crates/bolt/src/protocols/jolt/phases/lowering.rs b/crates/bolt/src/protocols/jolt/phases/lowering.rs index f85488a7fa..1c01888382 100644 --- a/crates/bolt/src/protocols/jolt/phases/lowering.rs +++ b/crates/bolt/src/protocols/jolt/phases/lowering.rs @@ -502,6 +502,29 @@ pub(super) fn lower_party_to_compute<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "piop.sumcheck_output_function_family" => { + let operands = lowered_operands(op, &value_map, 0)?; + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs( + op, + &[ + "term_gamma_power_offsets", + "term_functions", + "term_factor_counts", + "evals", + "factors", + ], + )?; + let operation = context.append_typed_op_with_owned_attrs( + &compute, + "compute.sumcheck_output_function_family", + Some(&symbol), + &attrs, + &operands, + &["!compute.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } "piop.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; diff --git a/crates/bolt/src/protocols/jolt/phases/stage1.rs b/crates/bolt/src/protocols/jolt/phases/stage1.rs index 5ebc8c04b9..fed2fadfc5 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage1.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage1.rs @@ -922,6 +922,29 @@ pub fn resolve_compute_kernels<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "compute.sumcheck_output_function_family" => { + let operands = lowered_operands(op, &value_map, 0)?; + let attrs = copy_attrs( + op, + &[ + "term_gamma_power_offsets", + "term_functions", + "term_factor_counts", + "evals", + "factors", + ], + )?; + let symbol = string_attr(op, "sym_name")?; + let operation = context.append_typed_op_with_owned_attrs( + &kernelized, + "compute.sumcheck_output_function_family", + Some(&symbol), + &attrs, + &operands, + &["!compute.field_value"], + )?; + insert_result_mapping(&mut value_map, op, operation, 0, 0)?; + } "compute.sumcheck_output_claim" => { let operands = lowered_operands(op, &value_map, 0)?; let attrs = copy_attrs(op, &["stage", "relation", "count", "polynomial_evals"])?; diff --git a/crates/bolt/src/protocols/jolt/phases/stage6.rs b/crates/bolt/src/protocols/jolt/phases/stage6.rs index 93e5624ce6..932a1e7af5 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage6.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage6.rs @@ -12,9 +12,10 @@ use super::super::params::JoltProtocolParams; use super::lowering::{lower_party_to_compute, transcript_squeeze_protocol_result_type}; use super::sumcheck_output::{ append_structured_polynomial_eval, append_sumcheck_output_claim, - append_sumcheck_output_eval_family, append_sumcheck_output_product_family, OutputClaimSpec, - OutputEvalFamilySpec, OutputProductFamilySpec, OutputProductFamilyTermSpec, - StructuredPolynomialPointSpec, StructuredPolynomialSpec, + append_sumcheck_output_eval_family, append_sumcheck_output_function_family, + append_sumcheck_output_product_family, OutputClaimSpec, OutputEvalFamilySpec, + OutputFunctionFamilySpec, OutputFunctionFamilyTermSpec, OutputProductFamilySpec, + OutputProductFamilyTermSpec, StructuredPolynomialPointSpec, StructuredPolynomialSpec, }; const BOOLEANITY_DEGREE: usize = 3; @@ -1768,32 +1769,30 @@ fn append_stage6_hamming_output_claim<'c, 'a>( hamming.0, inputs.hamming_lookup_output.point, )?; - let hamming_square = append_field_pow( - context, - module, - "stage6.hamming_booleanity.output.square.HammingWeight", - output_evals.hamming_weight, - 2, - )?; - let neg_hamming = append_field_neg( - context, - module, - "stage6.hamming_booleanity.output.neg.HammingWeight", - output_evals.hamming_weight, - )?; - let hamming_boolean = append_field_add( + let gamma_identity = append_field_one( context, module, - "stage6.hamming_booleanity.output.boolean", - hamming_square, - neg_hamming, + "stage6.hamming_booleanity.output.gamma_identity", )?; - let claim = append_field_mul( + let claim = append_sumcheck_output_function_family( context, module, - "stage6.hamming_booleanity.output.claim_expr", - hamming_boolean, - eq_lookup, + OutputFunctionFamilySpec { + symbol: "stage6.hamming_booleanity.output.family", + }, + gamma_identity, + &[OutputFunctionFamilyTermSpec { + gamma_power_offset: 0, + function: "boolean_zero", + eval: ( + "stage6.hamming_booleanity.eval.HammingWeight".to_owned(), + output_evals.hamming_weight, + ), + factors: vec![( + "stage6.hamming_booleanity.output.eq.LookupOutput".to_owned(), + eq_lookup, + )], + }], )?; append_sumcheck_output_claim( context, @@ -2169,23 +2168,6 @@ fn append_field_mul<'c, 'a>( append_field_binary(context, module, "field.mul", symbol, lhs, rhs) } -fn append_field_neg<'c, 'a>( - context: &'c MeliorContext, - module: &'a BoltModule<'c, Protocol>, - symbol: &str, - value: Value<'c, 'a>, -) -> Result, MlirError> { - let op = context.append_typed_op( - module, - "field.neg", - Some(symbol), - &[], - &[value], - &["!field.scalar"], - )?; - first_result(op, "field.neg") -} - fn append_field_pow<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, diff --git a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs index a6da832dc2..9e0b9d90e6 100644 --- a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs +++ b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs @@ -71,6 +71,18 @@ pub(crate) struct OutputProductFamilySpec<'a> { pub(crate) symbol: &'a str, } +pub(crate) struct OutputFunctionFamilyTermSpec<'c, 'a> { + pub(crate) gamma_power_offset: usize, + pub(crate) function: &'static str, + pub(crate) eval: (String, Value<'c, 'a>), + pub(crate) factors: Vec<(String, Value<'c, 'a>)>, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct OutputFunctionFamilySpec<'a> { + pub(crate) symbol: &'a str, +} + pub(crate) fn append_structured_polynomial_eval<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, @@ -239,6 +251,59 @@ pub(crate) fn append_sumcheck_output_product_family<'c, 'a>( first_result(op, "piop.sumcheck_output_product_family") } +pub(crate) fn append_sumcheck_output_function_family<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + spec: OutputFunctionFamilySpec<'_>, + gamma: Value<'c, 'a>, + terms: &[OutputFunctionFamilyTermSpec<'c, 'a>], +) -> Result, MlirError> { + let term_gamma_power_offsets = terms + .iter() + .map(|term| term.gamma_power_offset) + .collect::>(); + let term_factor_counts = terms + .iter() + .map(|term| term.factors.len()) + .collect::>(); + let mut operands = + Vec::with_capacity(1 + terms.len() + term_factor_counts.iter().sum::()); + operands.push(gamma); + operands.extend(terms.iter().map(|term| term.eval.1)); + operands.extend( + terms + .iter() + .flat_map(|term| term.factors.iter().map(|(_, value)| *value)), + ); + let functions = terms.iter().map(|term| term.function).collect::>(); + let eval_symbols = terms + .iter() + .map(|term| term.eval.0.as_str()) + .collect::>(); + let factor_symbols = terms + .iter() + .flat_map(|term| term.factors.iter().map(|(symbol, _)| symbol.as_str())) + .collect::>(); + let op = context.append_typed_op( + module, + "piop.sumcheck_output_function_family", + Some(spec.symbol), + &[ + ( + "term_gamma_power_offsets", + &usize_array_attr(&term_gamma_power_offsets), + ), + ("term_functions", &string_array_attr(&functions)), + ("term_factor_counts", &usize_array_attr(&term_factor_counts)), + ("evals", &symbol_array_attr(&eval_symbols)), + ("factors", &symbol_array_attr(&factor_symbols)), + ], + &operands, + &["!field.scalar"], + )?; + first_result(op, "piop.sumcheck_output_function_family") +} + fn first_result<'c, 'a>( operation: melior::ir::operation::OperationRef<'c, 'a>, operation_name: &str, @@ -269,3 +334,12 @@ fn symbol_array_attr(values: &[&str]) -> String { .join(", "); format!("[{values}]") } + +fn string_array_attr(values: &[&str]) -> String { + let values = values + .iter() + .map(|value| format!("\"{value}\"")) + .collect::>() + .join(", "); + format!("[{values}]") +} diff --git a/crates/bolt/src/schema.rs b/crates/bolt/src/schema.rs index d9bb0f3366..32f499fd10 100644 --- a/crates/bolt/src/schema.rs +++ b/crates/bolt/src/schema.rs @@ -45,6 +45,15 @@ const SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS: &[&str] = &[ "factors", ]; +const SUMCHECK_OUTPUT_FUNCTION_FAMILY_ATTRS: &[&str] = &[ + "sym_name", + "term_gamma_power_offsets", + "term_functions", + "term_factor_counts", + "evals", + "factors", +]; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct SchemaError { message: String, @@ -408,6 +417,11 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_min_shape(operation, 1, 1)?; require_sumcheck_output_product_family(operation) } + "piop.sumcheck_output_function_family" => { + require_attrs(operation, SUMCHECK_OUTPUT_FUNCTION_FAMILY_ATTRS)?; + require_min_shape(operation, 1, 1)?; + require_sumcheck_output_function_family(operation) + } "piop.sumcheck_output_claim" => { require_attrs( operation, @@ -775,6 +789,11 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_min_shape(operation, 1, 1)?; require_sumcheck_output_product_family(operation) } + "compute.sumcheck_output_function_family" => { + require_attrs(operation, SUMCHECK_OUTPUT_FUNCTION_FAMILY_ATTRS)?; + require_min_shape(operation, 1, 1)?; + require_sumcheck_output_function_family(operation) + } "compute.sumcheck_output_claim" => { require_attrs( operation, @@ -1125,6 +1144,11 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( require_min_shape(operation, 1, 1)?; require_sumcheck_output_product_family(operation) } + "cpu.sumcheck_output_function_family" => { + require_attrs(operation, SUMCHECK_OUTPUT_FUNCTION_FAMILY_ATTRS)?; + require_min_shape(operation, 1, 1)?; + require_sumcheck_output_function_family(operation) + } "cpu.sumcheck_output_claim" => { require_attrs( operation, @@ -1434,6 +1458,77 @@ fn require_sumcheck_output_product_family( Ok(()) } +fn require_sumcheck_output_function_family( + operation: OperationRef<'_, '_>, +) -> Result<(), SchemaError> { + let evals = symbol_array_attr(operation, "evals")?; + let factors = symbol_array_attr(operation, "factors")?; + let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; + let term_functions = string_array_attr(operation, "term_functions")?; + let term_factor_counts = int_array_attr(operation, "term_factor_counts")?; + if term_functions.len() != term_gamma_power_offsets.len() { + return Err(SchemaError::new(format!( + "{} attr `term_functions` length {} does not match term_gamma_power_offsets length {}", + operation_name(operation), + term_functions.len(), + term_gamma_power_offsets.len() + ))); + } + if term_factor_counts.len() != term_gamma_power_offsets.len() { + return Err(SchemaError::new(format!( + "{} attr `term_factor_counts` length {} does not match term_gamma_power_offsets length {}", + operation_name(operation), + term_factor_counts.len(), + term_gamma_power_offsets.len() + ))); + } + for (index, function) in term_functions.iter().enumerate() { + if function != "boolean_zero" { + return Err(SchemaError::new(format!( + "{} function-family term {index} has unsupported function `{function}`", + operation_name(operation) + ))); + } + } + if evals.len() != term_gamma_power_offsets.len() { + return Err(SchemaError::new(format!( + "{} attr `evals` length {} does not match term count {}", + operation_name(operation), + evals.len(), + term_gamma_power_offsets.len() + ))); + } + let expected_factors: usize = term_factor_counts.iter().sum(); + if factors.len() != expected_factors { + return Err(SchemaError::new(format!( + "{} attr `factors` length {} does not match sum(term_factor_counts) {}", + operation_name(operation), + factors.len(), + expected_factors + ))); + } + let expected_operands = 1 + evals.len() + factors.len(); + if operation.operand_count() != expected_operands { + return Err(SchemaError::new(format!( + "{} expected {expected_operands} operands, got {}", + operation_name(operation), + operation.operand_count() + ))); + } + let expected_symbols = evals.iter().chain(factors.iter()).collect::>(); + for (index, expected) in expected_symbols.iter().enumerate() { + let operand_index = index + 1; + let actual = operand_owner_symbol(operation, operand_index)?; + if &actual != *expected { + return Err(SchemaError::new(format!( + "{} operand {operand_index} expected @{expected}, got @{actual}", + operation_name(operation) + ))); + } + } + Ok(()) +} + fn require_sumcheck_output_claim(operation: OperationRef<'_, '_>) -> Result<(), SchemaError> { let count = int_attr(operation, "count")?; let polynomial_evals = symbol_array_attr(operation, "polynomial_evals")?; @@ -1711,6 +1806,34 @@ fn parse_symbol_array(attribute: &str) -> Option> { .collect() } +fn string_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, SchemaError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "string array"))?; + parse_string_array(&attribute).ok_or_else(|| attr_error(operation, attr, "string array")) +} + +fn parse_string_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| { + item.trim() + .strip_prefix('"')? + .strip_suffix('"') + .map(ToOwned::to_owned) + }) + .collect() +} + fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, SchemaError> { let attribute = operation .attribute(attr) diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index efc5435d8d..ecef93c2bc 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -920,9 +920,11 @@ fn jolt_stage6_protocol_defines_bytecode_booleanity_and_virtualization_flow() { assert!(text.contains("sym_name = \"stage6.ram_ra_virtual.output.claim\"")); assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.output.claim\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.claim\"")); + assert!(text.contains("sym_name = \"stage6.hamming_booleanity.output.family\"")); assert!(text.contains("sym_name = \"stage6.ram_ra_virtual.output.family\"")); assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.output.family\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.family\"")); + assert!(text.contains("\"piop.sumcheck_output_function_family\"")); assert!(text.contains("\"piop.sumcheck_output_product_family\"")); assert!(text.contains("\"piop.sumcheck_output_eval_family\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.eq.RdIncStage5\"")); @@ -1506,7 +1508,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(prover_program.transcript_absorb_bytes.is_empty()); assert_eq!(prover_program.opening_inputs.len(), 91); assert!(prover_program.field_exprs.len() > 150); - assert_eq!(prover_program.field_constants.len(), 2); + assert_eq!(prover_program.field_constants.len(), 3); assert!(prover_program.opening_equalities.is_empty()); assert_eq!(prover_program.claims.len(), 6); assert_eq!(prover_program.drivers.len(), 1); @@ -1527,7 +1529,30 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(verifier_program.output_values.len(), 7); assert_eq!(verifier_program.output_families.len(), 1); assert_eq!(verifier_program.output_product_families.len(), 2); + assert_eq!(verifier_program.output_function_families.len(), 1); assert_eq!(verifier_program.output_claims.len(), 4); + let hamming_function_families = verifier_program + .output_function_families + .iter() + .filter(|family| family.symbol == "stage6.hamming_booleanity.output.family") + .collect::>(); + assert_eq!(hamming_function_families.len(), 1); + let hamming_function_family = hamming_function_families[0]; + assert_eq!( + hamming_function_family.gamma, + "stage6.hamming_booleanity.output.gamma_identity" + ); + assert_eq!(hamming_function_family.terms.len(), 1); + assert_eq!(hamming_function_family.terms[0].gamma_power_offset, 0); + assert_eq!(hamming_function_family.terms[0].function, "boolean_zero"); + assert_eq!( + hamming_function_family.terms[0].eval, + "stage6.hamming_booleanity.eval.HammingWeight" + ); + assert_eq!( + hamming_function_family.terms[0].factors, + vec!["stage6.hamming_booleanity.output.eq.LookupOutput".to_owned()] + ); let ram_product_families = verifier_program .output_product_families .iter() @@ -1624,6 +1649,19 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(inc_claims.len(), 1); assert_eq!(inc_claims[0].eval_families, vec![inc_family.clone()]); assert!(inc_claims[0].product_families.is_empty()); + assert!(inc_claims[0].function_families.is_empty()); + let hamming_claims = verifier_program + .output_claims + .iter() + .filter(|claim| claim.claim_value == "stage6.hamming_booleanity.output.family") + .collect::>(); + assert_eq!(hamming_claims.len(), 1); + assert!(hamming_claims[0].eval_families.is_empty()); + assert!(hamming_claims[0].product_families.is_empty()); + assert_eq!( + hamming_claims[0].function_families, + vec![hamming_function_family.clone()] + ); let ram_ra_claims = verifier_program .output_claims .iter() @@ -1635,6 +1673,7 @@ fn stage6_rust_targets_extract_and_compile() { ram_ra_claims[0].product_families, vec![ram_product_family.clone()] ); + assert!(ram_ra_claims[0].function_families.is_empty()); let instruction_ra_claims = verifier_program .output_claims .iter() @@ -1646,6 +1685,7 @@ fn stage6_rust_targets_extract_and_compile() { instruction_ra_claims[0].product_families, vec![instruction_product_family.clone()] ); + assert!(instruction_ra_claims[0].function_families.is_empty()); assert_eq!(prover_program.point_zeros.len(), 1); assert_eq!( prover_program.point_slices.len(), @@ -1749,6 +1789,12 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("Stage6SumcheckOutputClaimPlan")); + assert!(verifier_source + .source + .contains("SumcheckOutputFunctionFamilyPlan")); + assert!(verifier_source + .source + .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES")); assert!(verifier_source .source .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES")); @@ -1761,6 +1807,9 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES")); + assert!(verifier_source + .source + .contains("stage6.hamming_booleanity.output.family")); assert!(verifier_source .source .contains("stage6.ram_ra_virtual.output.family")); @@ -1770,6 +1819,18 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("stage6.inc_claim_reduction.output.eq.RdIncStage5")); + assert!(!verifier_source + .source + .contains("stage6.hamming_booleanity.output.square.HammingWeight")); + assert!(!verifier_source + .source + .contains("stage6.hamming_booleanity.output.neg.HammingWeight")); + assert!(!verifier_source + .source + .contains("stage6.hamming_booleanity.output.boolean")); + assert!(!verifier_source + .source + .contains("stage6.hamming_booleanity.output.claim_expr")); assert!(!verifier_source .source .contains("stage6.ram_ra_virtual.output.product.RamRa")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 7c6d0c7b55..8ec0ae97e2 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -358,6 +358,19 @@ fn generated_structured_polynomial_point_order( } } +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_output_function_kind( + value: &str, +) -> bolt_verifier_runtime::SumcheckOutputFunctionKind { + match value { + "boolean_zero" => bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, + value => panic!("unsupported generated output function `{value}`"), + } +} + macro_rules! stage_program_step_kind { (kernel, $module:ident, $value:expr) => { super::leak_str($value) @@ -684,6 +697,33 @@ macro_rules! define_stage_adapter_impl { }) .collect(), ), + function_families: super::leak_slice( + plan.function_families + .iter() + .map(|family| bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { + symbol: super::leak_str(&family.symbol), + gamma: super::leak_str(&family.gamma), + terms: super::leak_slice( + family + .terms + .iter() + .map(|term| bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { + gamma_power_offset: term.gamma_power_offset, + function: super::generated_output_function_kind(&term.function), + eval: super::leak_str(&term.eval), + factors: super::leak_slice( + term + .factors + .iter() + .map(|symbol| super::leak_str(symbol)) + .collect(), + ), + }) + .collect(), + ), + }) + .collect(), + ), claim_value: super::leak_str(&plan.claim_value), }) .collect(), diff --git a/crates/jolt-prover/src/stages/stage6.rs b/crates/jolt-prover/src/stages/stage6.rs index dac4f6a1b0..86ef0c9c92 100644 --- a/crates/jolt-prover/src/stages/stage6.rs +++ b/crates/jolt-prover/src/stages/stage6.rs @@ -132,6 +132,7 @@ pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ Stage6FieldConstantPlan { symbol: "stage6.zero", field: "bn254_fr", value: 0 }, + Stage6FieldConstantPlan { symbol: "stage6.hamming_booleanity.output.gamma_identity", field: "bn254_fr", value: 1 }, Stage6FieldConstantPlan { symbol: "stage6.ram_ra_virtual.output.gamma_identity", field: "bn254_fr", value: 1 }, ]; diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index ca377c3185..a7afe6dc41 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -224,9 +224,9 @@ pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage3StructuredPolynomialEva ]; pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[ - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], claim_value: "stage3.spartan_shift.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], claim_value: "stage3.instruction_input.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: &[], claim_value: "stage3.registers.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage3.spartan_shift.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage3.instruction_input.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 328ef88936..d7a8dd455a 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -183,8 +183,8 @@ pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage4StructuredPolynomialEva ]; pub const STAGE4_SUMCHECK_OUTPUT_CLAIMS: &[Stage4SumcheckOutputClaimPlan] = &[ - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], claim_value: "stage4.registers_read_write.output.claim_expr" }, - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], claim_value: "stage4.ram_val_check.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage4.registers_read_write.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index b97eecb75d..39653d04c8 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -294,8 +294,8 @@ pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage5StructuredPolynomialEva ]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIMS: &[Stage5SumcheckOutputClaimPlan] = &[ - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index d11096b1ab..cb71eca680 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -290,6 +290,7 @@ pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ Stage6FieldConstantPlan { symbol: "stage6.zero", field: "bn254_fr", value: 0 }, + Stage6FieldConstantPlan { symbol: "stage6.hamming_booleanity.output.gamma_identity", field: "bn254_fr", value: 1 }, Stage6FieldConstantPlan { symbol: "stage6.ram_ra_virtual.output.gamma_identity", field: "bn254_fr", value: 1 }, ]; @@ -355,7 +356,6 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), - stage6_field_expr("stage6.hamming_booleanity.output.square.HammingWeight", Stage6FieldExprKind::Pow(2), &["stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.neg.HammingWeight", Stage6FieldExprKind::Neg, &["stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean", Stage6FieldExprKind::Add, &["stage6.hamming_booleanity.output.square.HammingWeight", "stage6.hamming_booleanity.output.neg.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.hamming_booleanity.output.boolean", "stage6.hamming_booleanity.output.eq.LookupOutput"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -610,6 +610,14 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage6StructuredPolynomialEva Stage6StructuredPolynomialEvalPlan { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.hamming_booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage1.LookupOutput", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse } }, ]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.hamming_booleanity.output.eq.LookupOutput"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.hamming_booleanity.eval.HammingWeight", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_0_FACTORS }, +]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan] = &[ + bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: "stage6.hamming_booleanity.output.family", gamma: "stage6.hamming_booleanity.output.gamma_identity", terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS }, +]; + pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.ram_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; @@ -680,10 +688,10 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES: &[bolt_verifier_runtime::Sumc ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[ - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], claim_value: "stage6.hamming_booleanity.output.claim_expr" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILIES, claim_value: "stage6.ram_ra_virtual.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, claim_value: "stage6.instruction_ra_virtual.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES, product_families: &[], claim_value: "stage6.inc_claim_reduction.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES, claim_value: "stage6.hamming_booleanity.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.ram_ra_virtual.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.instruction_ra_virtual.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES, product_families: &[], function_families: &[], claim_value: "stage6.inc_claim_reduction.output.family" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 85902260e4..738aa1f67c 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -288,7 +288,7 @@ pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES: &[bolt_verifier_runtime::Sumc ]; pub const STAGE7_SUMCHECK_OUTPUT_CLAIMS: &[Stage7SumcheckOutputClaimPlan] = &[ - Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES, product_families: &[], claim_value: "stage7.hamming_weight_claim_reduction.output.family" }, + Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES, product_families: &[], function_families: &[], claim_value: "stage7.hamming_weight_claim_reduction.output.family" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ From a97dca12d613eeed1f310ce8bba4872321b150c7 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 18:11:34 -0600 Subject: [PATCH 037/171] refactor(bolt): support identity output folds Represent product and function output-family identity folds with optional gamma instead of generated field.one constants. Cut Stage 6 hamming and RAM RA output families over to gamma-free identity folds and regenerate the checked-in artifacts. --- crates/bolt-verifier-runtime/src/lib.rs | 29 +++--- crates/bolt/irdl/compute.mlir | 8 +- crates/bolt/irdl/cpu.mlir | 8 +- crates/bolt/irdl/piop.mlir | 8 +- .../protocols/jolt/emit/rust/output_claims.rs | 97 ++++++++++++++----- .../src/protocols/jolt/phases/commitment.rs | 2 + .../src/protocols/jolt/phases/lowering.rs | 2 + .../bolt/src/protocols/jolt/phases/stage1.rs | 2 + .../bolt/src/protocols/jolt/phases/stage6.rs | 32 +----- .../protocols/jolt/phases/sumcheck_output.rs | 25 +++-- crates/bolt/src/schema.rs | 40 ++++++-- crates/bolt/tests/commitment_ir.rs | 20 ++-- crates/jolt-equivalence/src/plan_adapters.rs | 4 +- crates/jolt-prover/src/stages/stage6.rs | 2 - crates/jolt-verifier/src/stages/stage6.rs | 8 +- 15 files changed, 182 insertions(+), 105 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 9a5bc7c66e..f286e7cb74 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -388,7 +388,7 @@ pub struct SumcheckOutputProductFamilyTermPlan { #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct SumcheckOutputProductFamilyPlan { pub symbol: &'static str, - pub gamma: &'static str, + pub gamma: Option<&'static str>, pub terms: &'static [SumcheckOutputProductFamilyTermPlan], } @@ -408,7 +408,7 @@ pub struct SumcheckOutputFunctionFamilyTermPlan { #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct SumcheckOutputFunctionFamilyPlan { pub symbol: &'static str, - pub gamma: &'static str, + pub gamma: Option<&'static str>, pub terms: &'static [SumcheckOutputFunctionFamilyTermPlan], } @@ -1321,11 +1321,7 @@ fn evaluate_sumcheck_output_product_family( store: &ValueStore, scratch: &ScratchScalars, ) -> Result { - let gamma = scratch - .scalar_or(store, family.gamma) - .ok_or(RuntimePlanError::MissingValue { - symbol: family.gamma, - })?; + let gamma = output_family_gamma(family.gamma, store, scratch)?; let mut result = Fr::from_u64(0); for term in family.terms { if term.evals.is_empty() && term.factors.is_empty() { @@ -1352,11 +1348,7 @@ fn evaluate_sumcheck_output_function_family( store: &ValueStore, scratch: &ScratchScalars, ) -> Result { - let gamma = scratch - .scalar_or(store, family.gamma) - .ok_or(RuntimePlanError::MissingValue { - symbol: family.gamma, - })?; + let gamma = output_family_gamma(family.gamma, store, scratch)?; let mut result = Fr::from_u64(0); for term in family.terms { let eval = scratch @@ -1381,6 +1373,19 @@ fn evaluate_output_function(function: SumcheckOutputFunctionKind, eval: Fr) -> F } } +fn output_family_gamma( + gamma: Option<&'static str>, + store: &ValueStore, + scratch: &ScratchScalars, +) -> Result { + match gamma { + Some(symbol) => scratch + .scalar_or(store, symbol) + .ok_or(RuntimePlanError::MissingValue { symbol }), + None => Ok(Fr::from_u64(1)), + } +} + fn evaluate_structured_polynomial_point( plan: StructuredPolynomialPointPlan, raw_point: &[Fr], diff --git a/crates/bolt/irdl/compute.mlir b/crates/bolt/irdl/compute.mlir index 89f3425dc3..adc9303bc1 100644 --- a/crates/bolt/irdl/compute.mlir +++ b/crates/bolt/irdl/compute.mlir @@ -720,6 +720,7 @@ irdl.dialect @compute { irdl.operation @sumcheck_output_product_family { %value = irdl.parametric @compute::@field_value<> %sym = irdl.any + %gamma = irdl.any %term_gamma_power_offsets = irdl.any %term_eval_counts = irdl.any %term_factor_counts = irdl.any @@ -727,18 +728,20 @@ irdl.dialect @compute { %factors = irdl.any irdl.attributes { "sym_name" = %sym, + "gamma" = %gamma, "term_gamma_power_offsets" = %term_gamma_power_offsets, "term_eval_counts" = %term_eval_counts, "term_factor_counts" = %term_factor_counts, "evals" = %evals, "factors" = %factors } - irdl.operands(gamma: %value, inputs: variadic %value) + irdl.operands(inputs: variadic %value) irdl.results(value: %value) } irdl.operation @sumcheck_output_function_family { %value = irdl.parametric @compute::@field_value<> %sym = irdl.any + %gamma = irdl.any %term_gamma_power_offsets = irdl.any %term_functions = irdl.any %term_factor_counts = irdl.any @@ -746,13 +749,14 @@ irdl.dialect @compute { %factors = irdl.any irdl.attributes { "sym_name" = %sym, + "gamma" = %gamma, "term_gamma_power_offsets" = %term_gamma_power_offsets, "term_functions" = %term_functions, "term_factor_counts" = %term_factor_counts, "evals" = %evals, "factors" = %factors } - irdl.operands(gamma: %value, inputs: variadic %value) + irdl.operands(inputs: variadic %value) irdl.results(value: %value) } irdl.operation @sumcheck_output_claim { diff --git a/crates/bolt/irdl/cpu.mlir b/crates/bolt/irdl/cpu.mlir index 04b0d3e534..70254d1e73 100644 --- a/crates/bolt/irdl/cpu.mlir +++ b/crates/bolt/irdl/cpu.mlir @@ -650,6 +650,7 @@ irdl.dialect @cpu { irdl.operation @sumcheck_output_product_family { %value = irdl.parametric @cpu::@field_value<> %sym = irdl.any + %gamma = irdl.any %term_gamma_power_offsets = irdl.any %term_eval_counts = irdl.any %term_factor_counts = irdl.any @@ -657,18 +658,20 @@ irdl.dialect @cpu { %factors = irdl.any irdl.attributes { "sym_name" = %sym, + "gamma" = %gamma, "term_gamma_power_offsets" = %term_gamma_power_offsets, "term_eval_counts" = %term_eval_counts, "term_factor_counts" = %term_factor_counts, "evals" = %evals, "factors" = %factors } - irdl.operands(gamma: %value, inputs: variadic %value) + irdl.operands(inputs: variadic %value) irdl.results(value: %value) } irdl.operation @sumcheck_output_function_family { %value = irdl.parametric @cpu::@field_value<> %sym = irdl.any + %gamma = irdl.any %term_gamma_power_offsets = irdl.any %term_functions = irdl.any %term_factor_counts = irdl.any @@ -676,13 +679,14 @@ irdl.dialect @cpu { %factors = irdl.any irdl.attributes { "sym_name" = %sym, + "gamma" = %gamma, "term_gamma_power_offsets" = %term_gamma_power_offsets, "term_functions" = %term_functions, "term_factor_counts" = %term_factor_counts, "evals" = %evals, "factors" = %factors } - irdl.operands(gamma: %value, inputs: variadic %value) + irdl.operands(inputs: variadic %value) irdl.results(value: %value) } irdl.operation @sumcheck_output_claim { diff --git a/crates/bolt/irdl/piop.mlir b/crates/bolt/irdl/piop.mlir index 7c24891c65..7de81a43fc 100644 --- a/crates/bolt/irdl/piop.mlir +++ b/crates/bolt/irdl/piop.mlir @@ -268,6 +268,7 @@ irdl.dialect @piop { irdl.operation @sumcheck_output_product_family { %value = irdl.parametric @field::@scalar<> %sym = irdl.any + %gamma = irdl.any %term_gamma_power_offsets = irdl.any %term_eval_counts = irdl.any %term_factor_counts = irdl.any @@ -275,18 +276,20 @@ irdl.dialect @piop { %factors = irdl.any irdl.attributes { "sym_name" = %sym, + "gamma" = %gamma, "term_gamma_power_offsets" = %term_gamma_power_offsets, "term_eval_counts" = %term_eval_counts, "term_factor_counts" = %term_factor_counts, "evals" = %evals, "factors" = %factors } - irdl.operands(gamma: %value, inputs: variadic %value) + irdl.operands(inputs: variadic %value) irdl.results(value: %value) } irdl.operation @sumcheck_output_function_family { %value = irdl.parametric @field::@scalar<> %sym = irdl.any + %gamma = irdl.any %term_gamma_power_offsets = irdl.any %term_functions = irdl.any %term_factor_counts = irdl.any @@ -294,13 +297,14 @@ irdl.dialect @piop { %factors = irdl.any irdl.attributes { "sym_name" = %sym, + "gamma" = %gamma, "term_gamma_power_offsets" = %term_gamma_power_offsets, "term_functions" = %term_functions, "term_factor_counts" = %term_factor_counts, "evals" = %evals, "factors" = %factors } - irdl.operands(gamma: %value, inputs: variadic %value) + irdl.operands(inputs: variadic %value) irdl.results(value: %value) } irdl.operation @sumcheck_output_claim { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index 33e90b9d73..ffb9c88ff8 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -56,7 +56,7 @@ pub struct SumcheckOutputProductFamilyTermPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct SumcheckOutputProductFamilyPlan { pub symbol: String, - pub gamma: String, + pub gamma: Option, pub terms: Vec, } @@ -71,7 +71,7 @@ pub struct SumcheckOutputFunctionFamilyTermPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct SumcheckOutputFunctionFamilyPlan { pub symbol: String, - pub gamma: String, + pub gamma: Option, pub terms: Vec, } @@ -172,6 +172,7 @@ pub fn parse_output_product_family_plan( operation: OperationRef<'_, '_>, ) -> Result { let symbol = string_attr(operation, "sym_name")?; + let gamma = optional_symbol_array_attr(operation, "gamma")?; let evals = symbol_array_attr(operation, "evals")?; let factors = symbol_array_attr(operation, "factors")?; let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; @@ -201,9 +202,17 @@ pub fn parse_output_product_family_plan( term_factor_counts.iter().sum(), factors.len(), )?; - let gamma = operand_symbol(operation, 0)?; - let eval_end = 1 + evals.len(); - let eval_operands = operand_symbols(operation, 1, eval_end)?; + let eval_start = gamma.len(); + if let Some(gamma_symbol) = gamma.first() { + let gamma_operand = operand_symbol(operation, 0)?; + if gamma_operand != *gamma_symbol { + return Err(EmitError::new(format!( + "{stage} output product family @{symbol} gamma does not match operand" + ))); + } + } + let eval_end = eval_start + evals.len(); + let eval_operands = operand_symbols(operation, eval_start, eval_end)?; if evals != eval_operands { return Err(EmitError::new(format!( "{stage} output product family @{symbol} evals do not match operands" @@ -240,7 +249,7 @@ pub fn parse_output_product_family_plan( } Ok(SumcheckOutputProductFamilyPlan { symbol, - gamma, + gamma: gamma.into_iter().next(), terms, }) } @@ -250,6 +259,7 @@ pub fn parse_output_function_family_plan( operation: OperationRef<'_, '_>, ) -> Result { let symbol = string_attr(operation, "sym_name")?; + let gamma = optional_symbol_array_attr(operation, "gamma")?; let evals = symbol_array_attr(operation, "evals")?; let factors = symbol_array_attr(operation, "factors")?; let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; @@ -279,9 +289,17 @@ pub fn parse_output_function_family_plan( term_factor_counts.iter().sum(), factors.len(), )?; - let gamma = operand_symbol(operation, 0)?; - let eval_end = 1 + evals.len(); - let eval_operands = operand_symbols(operation, 1, eval_end)?; + let eval_start = gamma.len(); + if let Some(gamma_symbol) = gamma.first() { + let gamma_operand = operand_symbol(operation, 0)?; + if gamma_operand != *gamma_symbol { + return Err(EmitError::new(format!( + "{stage} output function family @{symbol} gamma does not match operand" + ))); + } + } + let eval_end = eval_start + evals.len(); + let eval_operands = operand_symbols(operation, eval_start, eval_end)?; if evals != eval_operands { return Err(EmitError::new(format!( "{stage} output function family @{symbol} evals do not match operands" @@ -313,7 +331,7 @@ pub fn parse_output_function_family_plan( } Ok(SumcheckOutputFunctionFamilyPlan { symbol, - gamma, + gamma: gamma.into_iter().next(), terms, }) } @@ -459,7 +477,7 @@ where } if let Some(family) = output_product_families_by_symbol.get(symbol.as_str()) { let _inserted = product_families.insert(family.symbol.clone()); - stack.push(family.gamma.clone()); + stack.extend(family.gamma.iter().cloned()); for term in &family.terms { stack.extend(term.evals.iter().cloned()); stack.extend(term.factors.iter().cloned()); @@ -467,7 +485,7 @@ where } if let Some(family) = output_function_families_by_symbol.get(symbol.as_str()) { let _inserted = function_families.insert(family.symbol.clone()); - stack.push(family.gamma.clone()); + stack.extend(family.gamma.iter().cloned()); for term in &family.terms { stack.push(term.eval.clone()); stack.extend(term.factors.iter().cloned()); @@ -596,11 +614,13 @@ pub fn verify_output_claims( } } for family in output_product_families { - if !field_values.contains(&family.gamma) { - return Err(EmitError::new(format!( - "{stage} output product family @{} references missing gamma @{}", - family.symbol, family.gamma - ))); + if let Some(gamma) = &family.gamma { + if !field_values.contains(gamma) { + return Err(EmitError::new(format!( + "{stage} output product family @{} references missing gamma @{}", + family.symbol, gamma + ))); + } } for term in &family.terms { if term.evals.is_empty() && term.factors.is_empty() { @@ -628,11 +648,13 @@ pub fn verify_output_claims( } } for family in output_function_families { - if !field_values.contains(&family.gamma) { - return Err(EmitError::new(format!( - "{stage} output function family @{} references missing gamma @{}", - family.symbol, family.gamma - ))); + if let Some(gamma) = &family.gamma { + if !field_values.contains(gamma) { + return Err(EmitError::new(format!( + "{stage} output function family @{} references missing gamma @{}", + family.symbol, gamma + ))); + } } for term in &family.terms { require_output_function(stage, &family.symbol, &term.function)?; @@ -852,7 +874,7 @@ fn emit_product_family_constants( family_rows.push(format!( " bolt_verifier_runtime::SumcheckOutputProductFamilyPlan {{ symbol: {}, gamma: {}, terms: {terms_name} }},", rust_str(&family.symbol), - rust_str(&family.gamma), + optional_rust_str(family.gamma.as_deref()), )); } let families_name = @@ -908,7 +930,7 @@ fn emit_function_family_constants( family_rows.push(format!( " bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan {{ symbol: {}, gamma: {}, terms: {terms_name} }},", rust_str(&family.symbol), - rust_str(&family.gamma), + optional_rust_str(family.gamma.as_deref()), )); } let families_name = @@ -1094,6 +1116,13 @@ fn rust_str(value: &str) -> String { format!("{value:?}") } +fn optional_rust_str(value: Option<&str>) -> String { + value.map_or_else( + || "None".to_owned(), + |value| format!("Some({})", rust_str(value)), + ) +} + fn rust_str_array(values: &[String]) -> String { values .iter() @@ -1130,6 +1159,22 @@ fn symbol_array_attr( parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) } +fn optional_symbol_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, EmitError> { + let values = symbol_array_attr(operation, attr)?; + if values.len() <= 1 { + Ok(values) + } else { + Err(EmitError::new(format!( + "{} attr `{attr}` expected zero or one symbols, got {}", + operation_name(operation), + values.len() + ))) + } +} + fn parse_symbol_array(attribute: &str) -> Option> { let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); if inner.is_empty() { @@ -1336,7 +1381,7 @@ mod tests { fn resolves_product_families_reachable_through_field_expressions() -> Result<(), EmitError> { let product_family = SumcheckOutputProductFamilyPlan { symbol: "product.family".to_owned(), - gamma: "product.gamma".to_owned(), + gamma: Some("product.gamma".to_owned()), terms: vec![SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: vec!["product.eval".to_owned()], @@ -1387,7 +1432,7 @@ mod tests { fn resolves_function_families_reachable_through_field_expressions() -> Result<(), EmitError> { let function_family = SumcheckOutputFunctionFamilyPlan { symbol: "function.family".to_owned(), - gamma: "function.gamma".to_owned(), + gamma: Some("function.gamma".to_owned()), terms: vec![SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: "boolean_zero".to_owned(), diff --git a/crates/bolt/src/protocols/jolt/phases/commitment.rs b/crates/bolt/src/protocols/jolt/phases/commitment.rs index 901edba7d7..ba8ea4ed42 100644 --- a/crates/bolt/src/protocols/jolt/phases/commitment.rs +++ b/crates/bolt/src/protocols/jolt/phases/commitment.rs @@ -978,6 +978,7 @@ pub fn lower_compute_to_cpu<'c>( let attrs = copy_attrs( op, &[ + "gamma", "term_gamma_power_offsets", "term_eval_counts", "term_factor_counts", @@ -1001,6 +1002,7 @@ pub fn lower_compute_to_cpu<'c>( let attrs = copy_attrs( op, &[ + "gamma", "term_gamma_power_offsets", "term_functions", "term_factor_counts", diff --git a/crates/bolt/src/protocols/jolt/phases/lowering.rs b/crates/bolt/src/protocols/jolt/phases/lowering.rs index 1c01888382..b5342d849d 100644 --- a/crates/bolt/src/protocols/jolt/phases/lowering.rs +++ b/crates/bolt/src/protocols/jolt/phases/lowering.rs @@ -485,6 +485,7 @@ pub(super) fn lower_party_to_compute<'c>( let attrs = copy_attrs( op, &[ + "gamma", "term_gamma_power_offsets", "term_eval_counts", "term_factor_counts", @@ -508,6 +509,7 @@ pub(super) fn lower_party_to_compute<'c>( let attrs = copy_attrs( op, &[ + "gamma", "term_gamma_power_offsets", "term_functions", "term_factor_counts", diff --git a/crates/bolt/src/protocols/jolt/phases/stage1.rs b/crates/bolt/src/protocols/jolt/phases/stage1.rs index fed2fadfc5..6018b09fa7 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage1.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage1.rs @@ -904,6 +904,7 @@ pub fn resolve_compute_kernels<'c>( let attrs = copy_attrs( op, &[ + "gamma", "term_gamma_power_offsets", "term_eval_counts", "term_factor_counts", @@ -927,6 +928,7 @@ pub fn resolve_compute_kernels<'c>( let attrs = copy_attrs( op, &[ + "gamma", "term_gamma_power_offsets", "term_functions", "term_factor_counts", diff --git a/crates/bolt/src/protocols/jolt/phases/stage6.rs b/crates/bolt/src/protocols/jolt/phases/stage6.rs index 932a1e7af5..f07ceab34a 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage6.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage6.rs @@ -1769,18 +1769,13 @@ fn append_stage6_hamming_output_claim<'c, 'a>( hamming.0, inputs.hamming_lookup_output.point, )?; - let gamma_identity = append_field_one( - context, - module, - "stage6.hamming_booleanity.output.gamma_identity", - )?; let claim = append_sumcheck_output_function_family( context, module, OutputFunctionFamilySpec { symbol: "stage6.hamming_booleanity.output.family", }, - gamma_identity, + None, &[OutputFunctionFamilyTermSpec { gamma_power_offset: 0, function: "boolean_zero", @@ -1829,18 +1824,13 @@ fn append_stage6_ram_ra_virtual_output_claim<'c, 'a>( ram.0, inputs.ram_ra_virtual.point, )?; - let gamma_identity = append_field_one( - context, - module, - "stage6.ram_ra_virtual.output.gamma_identity", - )?; let claim = append_sumcheck_output_product_family( context, module, OutputProductFamilySpec { symbol: "stage6.ram_ra_virtual.output.family", }, - gamma_identity, + None, &[OutputProductFamilyTermSpec { gamma_power_offset: 0, evals: output_evals @@ -1918,7 +1908,7 @@ fn append_stage6_instruction_ra_virtual_output_claim<'c, 'a>( OutputProductFamilySpec { symbol: "stage6.instruction_ra_virtual.output.family", }, - gamma, + Some(("stage6.instruction_ra_virtual.gamma", gamma)), &family_terms, )?; append_sumcheck_output_claim( @@ -2113,22 +2103,6 @@ fn append_field_zero<'c, 'a>( first_result(op, "field.zero") } -fn append_field_one<'c, 'a>( - context: &'c MeliorContext, - module: &'a BoltModule<'c, Protocol>, - symbol: &str, -) -> Result, MlirError> { - let op = context.append_typed_op( - module, - "field.one", - Some(symbol), - &[("field", "@bn254_fr")], - &[], - &["!field.scalar"], - )?; - first_result(op, "field.one") -} - fn append_field_binary<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, diff --git a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs index 9e0b9d90e6..f0a0402bf0 100644 --- a/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs +++ b/crates/bolt/src/protocols/jolt/phases/sumcheck_output.rs @@ -194,7 +194,7 @@ pub(crate) fn append_sumcheck_output_product_family<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, spec: OutputProductFamilySpec<'_>, - gamma: Value<'c, 'a>, + gamma: Option<(&str, Value<'c, 'a>)>, terms: &[OutputProductFamilyTermSpec<'c, 'a>], ) -> Result, MlirError> { let term_gamma_power_offsets = terms @@ -210,9 +210,13 @@ pub(crate) fn append_sumcheck_output_product_family<'c, 'a>( .map(|term| term.factors.len()) .collect::>(); let mut operands = Vec::with_capacity( - 1 + term_eval_counts.iter().sum::() + term_factor_counts.iter().sum::(), + gamma.map_or(0, |_| 1) + + term_eval_counts.iter().sum::() + + term_factor_counts.iter().sum::(), ); - operands.push(gamma); + if let Some((_, gamma)) = gamma { + operands.push(gamma); + } operands.extend( terms .iter() @@ -231,11 +235,13 @@ pub(crate) fn append_sumcheck_output_product_family<'c, 'a>( .iter() .flat_map(|term| term.factors.iter().map(|(symbol, _)| symbol.as_str())) .collect::>(); + let gamma_symbols = gamma.map(|(symbol, _)| vec![symbol]).unwrap_or_default(); let op = context.append_typed_op( module, "piop.sumcheck_output_product_family", Some(spec.symbol), &[ + ("gamma", &symbol_array_attr(&gamma_symbols)), ( "term_gamma_power_offsets", &usize_array_attr(&term_gamma_power_offsets), @@ -255,7 +261,7 @@ pub(crate) fn append_sumcheck_output_function_family<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, spec: OutputFunctionFamilySpec<'_>, - gamma: Value<'c, 'a>, + gamma: Option<(&str, Value<'c, 'a>)>, terms: &[OutputFunctionFamilyTermSpec<'c, 'a>], ) -> Result, MlirError> { let term_gamma_power_offsets = terms @@ -266,9 +272,12 @@ pub(crate) fn append_sumcheck_output_function_family<'c, 'a>( .iter() .map(|term| term.factors.len()) .collect::>(); - let mut operands = - Vec::with_capacity(1 + terms.len() + term_factor_counts.iter().sum::()); - operands.push(gamma); + let mut operands = Vec::with_capacity( + gamma.map_or(0, |_| 1) + terms.len() + term_factor_counts.iter().sum::(), + ); + if let Some((_, gamma)) = gamma { + operands.push(gamma); + } operands.extend(terms.iter().map(|term| term.eval.1)); operands.extend( terms @@ -284,11 +293,13 @@ pub(crate) fn append_sumcheck_output_function_family<'c, 'a>( .iter() .flat_map(|term| term.factors.iter().map(|(symbol, _)| symbol.as_str())) .collect::>(); + let gamma_symbols = gamma.map(|(symbol, _)| vec![symbol]).unwrap_or_default(); let op = context.append_typed_op( module, "piop.sumcheck_output_function_family", Some(spec.symbol), &[ + ("gamma", &symbol_array_attr(&gamma_symbols)), ( "term_gamma_power_offsets", &usize_array_attr(&term_gamma_power_offsets), diff --git a/crates/bolt/src/schema.rs b/crates/bolt/src/schema.rs index 32f499fd10..f46cf7ad57 100644 --- a/crates/bolt/src/schema.rs +++ b/crates/bolt/src/schema.rs @@ -38,6 +38,7 @@ const SUMCHECK_OUTPUT_EVAL_FAMILY_ATTRS: &[&str] = &[ const SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS: &[&str] = &[ "sym_name", + "gamma", "term_gamma_power_offsets", "term_eval_counts", "term_factor_counts", @@ -47,6 +48,7 @@ const SUMCHECK_OUTPUT_PRODUCT_FAMILY_ATTRS: &[&str] = &[ const SUMCHECK_OUTPUT_FUNCTION_FAMILY_ATTRS: &[&str] = &[ "sym_name", + "gamma", "term_gamma_power_offsets", "term_functions", "term_factor_counts", @@ -1385,6 +1387,7 @@ fn require_sumcheck_output_eval_family(operation: OperationRef<'_, '_>) -> Resul fn require_sumcheck_output_product_family( operation: OperationRef<'_, '_>, ) -> Result<(), SchemaError> { + let gamma = optional_symbol_array_attr(operation, "gamma")?; let evals = symbol_array_attr(operation, "evals")?; let factors = symbol_array_attr(operation, "factors")?; let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; @@ -1436,7 +1439,7 @@ fn require_sumcheck_output_product_family( expected_factors ))); } - let expected_operands = 1 + evals.len() + factors.len(); + let expected_operands = gamma.len() + evals.len() + factors.len(); if operation.operand_count() != expected_operands { return Err(SchemaError::new(format!( "{} expected {expected_operands} operands, got {}", @@ -1444,9 +1447,13 @@ fn require_sumcheck_output_product_family( operation.operand_count() ))); } - let expected_symbols = evals.iter().chain(factors.iter()).collect::>(); + let expected_symbols = gamma + .iter() + .chain(evals.iter()) + .chain(factors.iter()) + .collect::>(); for (index, expected) in expected_symbols.iter().enumerate() { - let operand_index = index + 1; + let operand_index = index; let actual = operand_owner_symbol(operation, operand_index)?; if &actual != *expected { return Err(SchemaError::new(format!( @@ -1461,6 +1468,7 @@ fn require_sumcheck_output_product_family( fn require_sumcheck_output_function_family( operation: OperationRef<'_, '_>, ) -> Result<(), SchemaError> { + let gamma = optional_symbol_array_attr(operation, "gamma")?; let evals = symbol_array_attr(operation, "evals")?; let factors = symbol_array_attr(operation, "factors")?; let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; @@ -1507,7 +1515,7 @@ fn require_sumcheck_output_function_family( expected_factors ))); } - let expected_operands = 1 + evals.len() + factors.len(); + let expected_operands = gamma.len() + evals.len() + factors.len(); if operation.operand_count() != expected_operands { return Err(SchemaError::new(format!( "{} expected {expected_operands} operands, got {}", @@ -1515,9 +1523,13 @@ fn require_sumcheck_output_function_family( operation.operand_count() ))); } - let expected_symbols = evals.iter().chain(factors.iter()).collect::>(); + let expected_symbols = gamma + .iter() + .chain(evals.iter()) + .chain(factors.iter()) + .collect::>(); for (index, expected) in expected_symbols.iter().enumerate() { - let operand_index = index + 1; + let operand_index = index; let actual = operand_owner_symbol(operation, operand_index)?; if &actual != *expected { return Err(SchemaError::new(format!( @@ -1795,6 +1807,22 @@ pub(crate) fn symbol_array_attr( parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) } +fn optional_symbol_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, SchemaError> { + let values = symbol_array_attr(operation, attr)?; + if values.len() <= 1 { + Ok(values) + } else { + Err(SchemaError::new(format!( + "{} attr `{attr}` expected zero or one symbols, got {}", + operation_name(operation), + values.len() + ))) + } +} + fn parse_symbol_array(attribute: &str) -> Option> { let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); if inner.is_empty() { diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index ecef93c2bc..5bebdd5e07 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1508,7 +1508,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(prover_program.transcript_absorb_bytes.is_empty()); assert_eq!(prover_program.opening_inputs.len(), 91); assert!(prover_program.field_exprs.len() > 150); - assert_eq!(prover_program.field_constants.len(), 3); + assert_eq!(prover_program.field_constants.len(), 1); assert!(prover_program.opening_equalities.is_empty()); assert_eq!(prover_program.claims.len(), 6); assert_eq!(prover_program.drivers.len(), 1); @@ -1538,10 +1538,7 @@ fn stage6_rust_targets_extract_and_compile() { .collect::>(); assert_eq!(hamming_function_families.len(), 1); let hamming_function_family = hamming_function_families[0]; - assert_eq!( - hamming_function_family.gamma, - "stage6.hamming_booleanity.output.gamma_identity" - ); + assert_eq!(hamming_function_family.gamma, None); assert_eq!(hamming_function_family.terms.len(), 1); assert_eq!(hamming_function_family.terms[0].gamma_power_offset, 0); assert_eq!(hamming_function_family.terms[0].function, "boolean_zero"); @@ -1560,10 +1557,7 @@ fn stage6_rust_targets_extract_and_compile() { .collect::>(); assert_eq!(ram_product_families.len(), 1); let ram_product_family = ram_product_families[0]; - assert_eq!( - ram_product_family.gamma, - "stage6.ram_ra_virtual.output.gamma_identity" - ); + assert_eq!(ram_product_family.gamma, None); assert_eq!(ram_product_family.terms.len(), 1); assert_eq!(ram_product_family.terms[0].gamma_power_offset, 0); assert_eq!( @@ -1585,7 +1579,7 @@ fn stage6_rust_targets_extract_and_compile() { let instruction_product_family = instruction_product_families[0]; assert_eq!( instruction_product_family.gamma, - "stage6.instruction_ra_virtual.gamma" + Some("stage6.instruction_ra_virtual.gamma".to_owned()) ); assert_eq!( instruction_product_family.terms.len(), @@ -1831,12 +1825,18 @@ fn stage6_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("stage6.hamming_booleanity.output.claim_expr")); + assert!(!verifier_source + .source + .contains("stage6.hamming_booleanity.output.gamma_identity")); assert!(!verifier_source .source .contains("stage6.ram_ra_virtual.output.product.RamRa")); assert!(!verifier_source .source .contains("stage6.ram_ra_virtual.output.claim_expr")); + assert!(!verifier_source + .source + .contains("stage6.ram_ra_virtual.output.gamma_identity")); assert!(!verifier_source .source .contains("stage6.instruction_ra_virtual.output.product.InstructionRa_0")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 8ec0ae97e2..babe2a00ae 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -670,7 +670,7 @@ macro_rules! define_stage_adapter_impl { .iter() .map(|family| bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: super::leak_str(&family.symbol), - gamma: super::leak_str(&family.gamma), + gamma: family.gamma.as_ref().map(|gamma| super::leak_str(gamma)), terms: super::leak_slice( family .terms @@ -702,7 +702,7 @@ macro_rules! define_stage_adapter_impl { .iter() .map(|family| bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: super::leak_str(&family.symbol), - gamma: super::leak_str(&family.gamma), + gamma: family.gamma.as_ref().map(|gamma| super::leak_str(gamma)), terms: super::leak_slice( family .terms diff --git a/crates/jolt-prover/src/stages/stage6.rs b/crates/jolt-prover/src/stages/stage6.rs index 86ef0c9c92..37c8c578a3 100644 --- a/crates/jolt-prover/src/stages/stage6.rs +++ b/crates/jolt-prover/src/stages/stage6.rs @@ -132,8 +132,6 @@ pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ Stage6FieldConstantPlan { symbol: "stage6.zero", field: "bn254_fr", value: 0 }, - Stage6FieldConstantPlan { symbol: "stage6.hamming_booleanity.output.gamma_identity", field: "bn254_fr", value: 1 }, - Stage6FieldConstantPlan { symbol: "stage6.ram_ra_virtual.output.gamma_identity", field: "bn254_fr", value: 1 }, ]; pub const STAGE6_FIELD_EXPR_OPERANDS_0: &[&str] = &["stage6.booleanity.gamma"]; diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index cb71eca680..626a133dfe 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -290,8 +290,6 @@ pub const STAGE6_OPENING_INPUTS: &[Stage6OpeningInputPlan] = &[ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ Stage6FieldConstantPlan { symbol: "stage6.zero", field: "bn254_fr", value: 0 }, - Stage6FieldConstantPlan { symbol: "stage6.hamming_booleanity.output.gamma_identity", field: "bn254_fr", value: 1 }, - Stage6FieldConstantPlan { symbol: "stage6.ram_ra_virtual.output.gamma_identity", field: "bn254_fr", value: 1 }, ]; const fn stage6_field_expr(symbol: &'static str, kind: Stage6FieldExprKind, operands: &'static [&'static str]) -> Stage6FieldExprPlan { @@ -615,7 +613,7 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS: &[bolt_verifie bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.hamming_booleanity.eval.HammingWeight", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_0_FACTORS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: "stage6.hamming_booleanity.output.family", gamma: "stage6.hamming_booleanity.output.gamma_identity", terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: "stage6.hamming_booleanity.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ @@ -628,7 +626,7 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERM_0_FACTORS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: "stage6.ram_ra_virtual.output.gamma_identity", terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERMS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERMS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ @@ -662,7 +660,7 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_FACTORS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: "stage6.instruction_ra_virtual.gamma", terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: Some("stage6.instruction_ra_virtual.gamma"), terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ From 1241524d99d2653c8683d743bc2f445ef167fd34 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 18:21:50 -0600 Subject: [PATCH 038/171] refactor(bolt): remove stale stage67 helpers Delete obsolete Stage 6/7 relation helpers that were already replaced by structured output-claim plans, and trim their stale Stage 6 symbol table fields. Add a cleanup test so the dead Tier B helpers do not reappear beside the typed output-plan path. --- .../src/protocols/jolt/emit/rust/stage6.rs | 15 -- .../jolt/verifier_jolt_relations.rs.template | 143 +----------------- crates/bolt/tests/verifier_cleanup.rs | 55 +++++++ .../src/stages/jolt_relations.rs | 143 +----------------- crates/jolt-verifier/src/stages/stage6.rs | 15 -- 5 files changed, 65 insertions(+), 306 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index b74ecbd848..89cf9d3eda 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1466,21 +1466,6 @@ const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { booleanity_instruction_ra_prefix: "stage6.booleanity.eval.InstructionRa_", booleanity_bytecode_ra_prefix: "stage6.booleanity.eval.BytecodeRa_", booleanity_ram_ra_prefix: "stage6.booleanity.eval.RamRa_", - hamming_weight_eval: "stage6.hamming_booleanity.eval.HammingWeight", - hamming_lookup_output: "stage6.input.stage1.LookupOutput", - ram_ra_virtual_cycle: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", - ram_ra_virtual_eval_prefix: "stage6.ram_ra_virtual.eval.RamRa_", - instruction_ra_virtual_cycle: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", - instruction_ra_virtual_eval_prefix: "stage6.instruction_ra_virtual.eval.InstructionRa_", - instruction_ra_virtual_input_prefix: "stage6.input.stage5.instruction_read_raf.InstructionRa_", - instruction_ra_virtual_gamma: "stage6.instruction_ra_virtual.gamma", - inc_ram_stage2: "stage6.input.stage2.ram_read_write.RamInc", - inc_ram_stage4: "stage6.input.stage4.ram_val_check.RamInc", - inc_rd_stage4: "stage6.input.stage4.registers_read_write.RdInc", - inc_rd_stage5: "stage6.input.stage5.registers_val_evaluation.RdInc", - inc_gamma: "stage6.inc_claim_reduction.gamma", - inc_ram_eval: "stage6.inc_claim_reduction.eval.RamInc", - inc_rd_eval: "stage6.inc_claim_reduction.eval.RdInc", }; const STAGE6_BYTECODE_SYMBOLS: Stage67BytecodeSymbols = Stage67BytecodeSymbols { diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 89a427cc27..1b3c5cb4a5 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -12,9 +12,8 @@ //! - point normalizations for the Jolt bytecode and instruction RA //! read-RAF lookup arguments //! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement -//! - the `expected_stage67_*` relation evaluators for Stage 6/7 booleanity, -//! bytecode-read-RAF, hamming booleanity, RAM RA virtual, -//! instruction RA virtual, and inc-claim-reduction relations +//! - the remaining `expected_stage67_*` relation evaluators for Stage 6 +//! booleanity and bytecode-read-RAF relations //! - the small Jolt-specific field-math helpers //! (`operand_polynomial_eval`, `identity_polynomial_eval`, //! `lt_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt @@ -31,9 +30,9 @@ use jolt_field::{Field, Fr, MulPow2, RingCore}; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - eval_by_name, field_powers, indexed_boolean_eq, indexed_evals_by_prefix_any, prefix_point, - reverse_slice, store_point, store_scalar, suffix_point, OpeningInputPlan, RuntimePlanError, - StageNamedEval, SumcheckInstanceResultPlan, ValueStore, + field_powers, indexed_boolean_eq, indexed_evals_by_prefix_any, prefix_point, store_point, + store_scalar, suffix_point, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, + ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -94,21 +93,6 @@ pub struct Stage67RelationSymbols { pub booleanity_instruction_ra_prefix: &'static str, pub booleanity_bytecode_ra_prefix: &'static str, pub booleanity_ram_ra_prefix: &'static str, - pub hamming_weight_eval: &'static str, - pub hamming_lookup_output: &'static str, - pub ram_ra_virtual_cycle: &'static str, - pub ram_ra_virtual_eval_prefix: &'static str, - pub instruction_ra_virtual_cycle: &'static str, - pub instruction_ra_virtual_eval_prefix: &'static str, - pub instruction_ra_virtual_input_prefix: &'static str, - pub instruction_ra_virtual_gamma: &'static str, - pub inc_ram_stage2: &'static str, - pub inc_ram_stage4: &'static str, - pub inc_rd_stage4: &'static str, - pub inc_rd_stage5: &'static str, - pub inc_gamma: &'static str, - pub inc_ram_eval: &'static str, - pub inc_rd_eval: &'static str, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -275,123 +259,6 @@ pub fn expected_stage67_booleanity( Ok(eq_eval * booleanity) } -pub fn expected_stage67_hamming_booleanity( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let hamming = eval_by_name(evals, symbols.hamming_weight_eval)?; - let lookup_output_point = reverse_slice(store_point(store, symbols.hamming_lookup_output)?); - if lookup_output_point.len() != local_point.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.hamming_lookup_output, - expected: local_point.len(), - actual: lookup_output_point.len(), - }); - } - let eq_eval = EqPolynomial::::mle(local_point, &lookup_output_point); - Ok((hamming.square() - hamming) * eq_eval) -} - -pub fn expected_stage67_ram_ra_virtual( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let r_cycle = suffix_point( - store_point(store, symbols.ram_ra_virtual_cycle)?, - r_cycle_reduced.len(), - symbols.ram_ra_virtual_cycle, - )?; - let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); - let ram_ra = indexed_evals_by_prefix_any(evals, symbols.ram_ra_virtual_eval_prefix)? - .into_iter() - .product::(); - Ok(eq_eval * ram_ra) -} - -pub fn expected_stage67_instruction_ra_virtual( - opening_inputs: &[OpeningInputPlan], - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let r_cycle = suffix_point( - store_point(store, symbols.instruction_ra_virtual_cycle)?, - r_cycle_reduced.len(), - symbols.instruction_ra_virtual_cycle, - )?; - let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); - let committed_ra = - indexed_evals_by_prefix_any(evals, symbols.instruction_ra_virtual_eval_prefix)?; - let virtual_count = opening_inputs - .iter() - .filter(|input| { - input - .symbol - .starts_with(symbols.instruction_ra_virtual_input_prefix) - }) - .count(); - if virtual_count == 0 || committed_ra.len() % virtual_count != 0 { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.instruction_ra_virtual_eval_prefix, - expected: virtual_count, - actual: committed_ra.len(), - }); - } - let committed_per_virtual = committed_ra.len() / virtual_count; - let gamma = store_scalar(store, symbols.instruction_ra_virtual_gamma)?; - let mut gamma_power = Fr::from_u64(1); - let mut value = Fr::from_u64(0); - for chunk in committed_ra.chunks(committed_per_virtual) { - value += gamma_power * chunk.iter().copied().product::(); - gamma_power *= gamma; - } - Ok(eq_eval * value) -} - -pub fn expected_stage67_inc_claim_reduction( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let ram_inc_stage2 = suffix_point( - store_point(store, symbols.inc_ram_stage2)?, - r_cycle_reduced.len(), - symbols.inc_ram_stage2, - )?; - let ram_inc_stage4 = suffix_point( - store_point(store, symbols.inc_ram_stage4)?, - r_cycle_reduced.len(), - symbols.inc_ram_stage4, - )?; - let rd_inc_stage4 = suffix_point( - store_point(store, symbols.inc_rd_stage4)?, - r_cycle_reduced.len(), - symbols.inc_rd_stage4, - )?; - let rd_inc_stage5 = suffix_point( - store_point(store, symbols.inc_rd_stage5)?, - r_cycle_reduced.len(), - symbols.inc_rd_stage5, - )?; - let gamma = store_scalar(store, symbols.inc_gamma)?; - let eq_ram_combined = EqPolynomial::::mle(ram_inc_stage2, &r_cycle_reduced) - + gamma * EqPolynomial::::mle(ram_inc_stage4, &r_cycle_reduced); - let eq_rd_combined = EqPolynomial::::mle(rd_inc_stage4, &r_cycle_reduced) - + gamma * EqPolynomial::::mle(rd_inc_stage5, &r_cycle_reduced); - let ram_inc = eval_by_name(evals, symbols.inc_ram_eval)?; - let rd_inc = eval_by_name(evals, symbols.inc_rd_eval)?; - Ok(ram_inc * eq_ram_combined + gamma.square() * rd_inc * eq_rd_combined) -} - fn stage67_booleanity_evals( evals: &[StageNamedEval], symbols: &Stage67RelationSymbols, diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 29ae290299..1c39b4b56c 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -383,6 +383,61 @@ fn checked_in_generated_verifier_uses_typed_top_level_program() { } } +#[test] +fn stage67_output_plan_cutover_removed_obsolete_relation_helpers() { + let root = workspace_root(); + let generated_relations = root.join("crates/jolt-verifier/src/stages/jolt_relations.rs"); + if !generated_relations.exists() { + return; + } + + let relation_sources = [ + generated_relations, + root.join("crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template"), + ]; + for path in relation_sources { + let source = std::fs::read_to_string(&path).expect("read Jolt relation source"); + for stale in [ + "expected_stage67_hamming_booleanity", + "expected_stage67_ram_ra_virtual", + "expected_stage67_instruction_ra_virtual", + "expected_stage67_inc_claim_reduction", + ] { + assert!( + !source.contains(stale), + "`{}` still contains obsolete Stage 6/7 relation helper `{stale}`", + path.display() + ); + } + } + + let stage6_source = + std::fs::read_to_string(root.join("crates/jolt-verifier/src/stages/stage6.rs")) + .expect("read generated Stage 6 verifier source"); + for stale_field in [ + "hamming_weight_eval", + "hamming_lookup_output", + "ram_ra_virtual_cycle", + "ram_ra_virtual_eval_prefix", + "instruction_ra_virtual_cycle", + "instruction_ra_virtual_eval_prefix", + "instruction_ra_virtual_input_prefix", + "instruction_ra_virtual_gamma", + "inc_ram_stage2", + "inc_ram_stage4", + "inc_rd_stage4", + "inc_rd_stage5", + "inc_gamma", + "inc_ram_eval", + "inc_rd_eval", + ] { + assert!( + !stage6_source.contains(stale_field), + "generated Stage 6 relation symbol table still exposes obsolete field `{stale_field}`" + ); + } +} + #[test] fn verifier_cpu_fixtures_are_kernel_free() { let fixtures = workspace_root().join("crates/bolt/tests/fixtures"); diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 89a427cc27..1b3c5cb4a5 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -12,9 +12,8 @@ //! - point normalizations for the Jolt bytecode and instruction RA //! read-RAF lookup arguments //! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement -//! - the `expected_stage67_*` relation evaluators for Stage 6/7 booleanity, -//! bytecode-read-RAF, hamming booleanity, RAM RA virtual, -//! instruction RA virtual, and inc-claim-reduction relations +//! - the remaining `expected_stage67_*` relation evaluators for Stage 6 +//! booleanity and bytecode-read-RAF relations //! - the small Jolt-specific field-math helpers //! (`operand_polynomial_eval`, `identity_polynomial_eval`, //! `lt_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt @@ -31,9 +30,9 @@ use jolt_field::{Field, Fr, MulPow2, RingCore}; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - eval_by_name, field_powers, indexed_boolean_eq, indexed_evals_by_prefix_any, prefix_point, - reverse_slice, store_point, store_scalar, suffix_point, OpeningInputPlan, RuntimePlanError, - StageNamedEval, SumcheckInstanceResultPlan, ValueStore, + field_powers, indexed_boolean_eq, indexed_evals_by_prefix_any, prefix_point, store_point, + store_scalar, suffix_point, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, + ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -94,21 +93,6 @@ pub struct Stage67RelationSymbols { pub booleanity_instruction_ra_prefix: &'static str, pub booleanity_bytecode_ra_prefix: &'static str, pub booleanity_ram_ra_prefix: &'static str, - pub hamming_weight_eval: &'static str, - pub hamming_lookup_output: &'static str, - pub ram_ra_virtual_cycle: &'static str, - pub ram_ra_virtual_eval_prefix: &'static str, - pub instruction_ra_virtual_cycle: &'static str, - pub instruction_ra_virtual_eval_prefix: &'static str, - pub instruction_ra_virtual_input_prefix: &'static str, - pub instruction_ra_virtual_gamma: &'static str, - pub inc_ram_stage2: &'static str, - pub inc_ram_stage4: &'static str, - pub inc_rd_stage4: &'static str, - pub inc_rd_stage5: &'static str, - pub inc_gamma: &'static str, - pub inc_ram_eval: &'static str, - pub inc_rd_eval: &'static str, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -275,123 +259,6 @@ pub fn expected_stage67_booleanity( Ok(eq_eval * booleanity) } -pub fn expected_stage67_hamming_booleanity( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let hamming = eval_by_name(evals, symbols.hamming_weight_eval)?; - let lookup_output_point = reverse_slice(store_point(store, symbols.hamming_lookup_output)?); - if lookup_output_point.len() != local_point.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.hamming_lookup_output, - expected: local_point.len(), - actual: lookup_output_point.len(), - }); - } - let eq_eval = EqPolynomial::::mle(local_point, &lookup_output_point); - Ok((hamming.square() - hamming) * eq_eval) -} - -pub fn expected_stage67_ram_ra_virtual( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let r_cycle = suffix_point( - store_point(store, symbols.ram_ra_virtual_cycle)?, - r_cycle_reduced.len(), - symbols.ram_ra_virtual_cycle, - )?; - let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); - let ram_ra = indexed_evals_by_prefix_any(evals, symbols.ram_ra_virtual_eval_prefix)? - .into_iter() - .product::(); - Ok(eq_eval * ram_ra) -} - -pub fn expected_stage67_instruction_ra_virtual( - opening_inputs: &[OpeningInputPlan], - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let r_cycle = suffix_point( - store_point(store, symbols.instruction_ra_virtual_cycle)?, - r_cycle_reduced.len(), - symbols.instruction_ra_virtual_cycle, - )?; - let eq_eval = EqPolynomial::::mle(r_cycle, &r_cycle_reduced); - let committed_ra = - indexed_evals_by_prefix_any(evals, symbols.instruction_ra_virtual_eval_prefix)?; - let virtual_count = opening_inputs - .iter() - .filter(|input| { - input - .symbol - .starts_with(symbols.instruction_ra_virtual_input_prefix) - }) - .count(); - if virtual_count == 0 || committed_ra.len() % virtual_count != 0 { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.instruction_ra_virtual_eval_prefix, - expected: virtual_count, - actual: committed_ra.len(), - }); - } - let committed_per_virtual = committed_ra.len() / virtual_count; - let gamma = store_scalar(store, symbols.instruction_ra_virtual_gamma)?; - let mut gamma_power = Fr::from_u64(1); - let mut value = Fr::from_u64(0); - for chunk in committed_ra.chunks(committed_per_virtual) { - value += gamma_power * chunk.iter().copied().product::(); - gamma_power *= gamma; - } - Ok(eq_eval * value) -} - -pub fn expected_stage67_inc_claim_reduction( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - symbols: &Stage67RelationSymbols, -) -> Result { - let r_cycle_reduced = reverse_slice(local_point); - let ram_inc_stage2 = suffix_point( - store_point(store, symbols.inc_ram_stage2)?, - r_cycle_reduced.len(), - symbols.inc_ram_stage2, - )?; - let ram_inc_stage4 = suffix_point( - store_point(store, symbols.inc_ram_stage4)?, - r_cycle_reduced.len(), - symbols.inc_ram_stage4, - )?; - let rd_inc_stage4 = suffix_point( - store_point(store, symbols.inc_rd_stage4)?, - r_cycle_reduced.len(), - symbols.inc_rd_stage4, - )?; - let rd_inc_stage5 = suffix_point( - store_point(store, symbols.inc_rd_stage5)?, - r_cycle_reduced.len(), - symbols.inc_rd_stage5, - )?; - let gamma = store_scalar(store, symbols.inc_gamma)?; - let eq_ram_combined = EqPolynomial::::mle(ram_inc_stage2, &r_cycle_reduced) - + gamma * EqPolynomial::::mle(ram_inc_stage4, &r_cycle_reduced); - let eq_rd_combined = EqPolynomial::::mle(rd_inc_stage4, &r_cycle_reduced) - + gamma * EqPolynomial::::mle(rd_inc_stage5, &r_cycle_reduced); - let ram_inc = eval_by_name(evals, symbols.inc_ram_eval)?; - let rd_inc = eval_by_name(evals, symbols.inc_rd_eval)?; - Ok(ram_inc * eq_ram_combined + gamma.square() * rd_inc * eq_rd_combined) -} - fn stage67_booleanity_evals( evals: &[StageNamedEval], symbols: &Stage67RelationSymbols, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 626a133dfe..8ab1faac17 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -104,21 +104,6 @@ const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { booleanity_instruction_ra_prefix: "stage6.booleanity.eval.InstructionRa_", booleanity_bytecode_ra_prefix: "stage6.booleanity.eval.BytecodeRa_", booleanity_ram_ra_prefix: "stage6.booleanity.eval.RamRa_", - hamming_weight_eval: "stage6.hamming_booleanity.eval.HammingWeight", - hamming_lookup_output: "stage6.input.stage1.LookupOutput", - ram_ra_virtual_cycle: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", - ram_ra_virtual_eval_prefix: "stage6.ram_ra_virtual.eval.RamRa_", - instruction_ra_virtual_cycle: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", - instruction_ra_virtual_eval_prefix: "stage6.instruction_ra_virtual.eval.InstructionRa_", - instruction_ra_virtual_input_prefix: "stage6.input.stage5.instruction_read_raf.InstructionRa_", - instruction_ra_virtual_gamma: "stage6.instruction_ra_virtual.gamma", - inc_ram_stage2: "stage6.input.stage2.ram_read_write.RamInc", - inc_ram_stage4: "stage6.input.stage4.ram_val_check.RamInc", - inc_rd_stage4: "stage6.input.stage4.registers_read_write.RdInc", - inc_rd_stage5: "stage6.input.stage5.registers_val_evaluation.RdInc", - inc_gamma: "stage6.inc_claim_reduction.gamma", - inc_ram_eval: "stage6.inc_claim_reduction.eval.RamInc", - inc_rd_eval: "stage6.inc_claim_reduction.eval.RdInc", }; const STAGE6_BYTECODE_SYMBOLS: Stage67BytecodeSymbols = Stage67BytecodeSymbols { From 38f13318995da74b3fb05daf109e733183b9ca42 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 18:39:44 -0600 Subject: [PATCH 039/171] refactor(bolt): plan stage6 booleanity output Route Stage 6 Booleanity through structured output-claim plans instead of the Tier B relation helper. Remove stale gamma placeholder field rows, regenerate Stage 6 prover/verifier artifacts, and guard the cutover in extraction and cleanup tests. --- .../src/protocols/jolt/emit/rust/stage6.rs | 25 +- .../bolt/src/protocols/jolt/phases/stage6.rs | 150 +- .../jolt/verifier_jolt_relations.rs.template | 90 +- crates/bolt/tests/commitment_ir.rs | 91 +- crates/bolt/tests/verifier_cleanup.rs | 7 + crates/jolt-prover/src/stages/stage6.rs | 1300 ++++++++--------- .../src/stages/jolt_relations.rs | 90 +- crates/jolt-verifier/src/stages/stage6.rs | 320 ++-- 8 files changed, 1014 insertions(+), 1059 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 89cf9d3eda..136322124d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1142,7 +1142,7 @@ impl Stage6CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ - use super::jolt_relations::{expected_stage67_booleanity, expected_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols};\n\ + use super::jolt_relations::{expected_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -1459,13 +1459,6 @@ pub struct Stage6VerifierData { const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { hamming_booleanity_instance: "stage6.hamming_booleanity.instance", - booleanity_point: "stage6.booleanity.point", - stage5_instruction_ra0: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", - booleanity_combined_point: "stage6.booleanity.combined_point", - booleanity_gamma: "stage6.booleanity.gamma", - booleanity_instruction_ra_prefix: "stage6.booleanity.eval.InstructionRa_", - booleanity_bytecode_ra_prefix: "stage6.booleanity.eval.BytecodeRa_", - booleanity_ram_ra_prefix: "stage6.booleanity.eval.RamRa_", }; const STAGE6_BYTECODE_SYMBOLS: Stage67BytecodeSymbols = Stage67BytecodeSymbols { @@ -2553,10 +2546,8 @@ fn expected_batched_output_claim( })?; expected_bytecode_read_raf(program, data, store, evals, local_point)? } - Stage6RelationKind::Stage6Booleanity => { - expected_booleanity(program, store, evals, local_point)? - } - Stage6RelationKind::Stage6HammingBooleanity + Stage6RelationKind::Stage6Booleanity + | Stage6RelationKind::Stage6HammingBooleanity | Stage6RelationKind::Stage6RamRaVirtual | Stage6RelationKind::Stage6InstructionRaVirtual | Stage6RelationKind::Stage6IncClaimReduction => expected_plan_output_claim( @@ -2617,16 +2608,6 @@ fn expected_bytecode_read_raf( )?) } -fn expected_booleanity( - program: &'static Stage6VerifierProgramPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - let log_t = stage6_trace_rounds(program)?; - Ok(expected_stage67_booleanity(store, evals, local_point, log_t, &STAGE6_RELATION_SYMBOLS)?) -} - fn stage6_trace_rounds( program: &'static Stage6VerifierProgramPlan, ) -> Result { diff --git a/crates/bolt/src/protocols/jolt/phases/stage6.rs b/crates/bolt/src/protocols/jolt/phases/stage6.rs index f07ceab34a..96081f7045 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage6.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage6.rs @@ -143,7 +143,6 @@ pub fn build_stage6_protocol<'c>( "challenge_scalar", 1, )?; - append_booleanity_power_placeholders(context, &module, params, booleanity_gamma)?; let (state, inst_ra_gamma) = append_transcript_squeeze( context, &module, @@ -177,6 +176,7 @@ pub fn build_stage6_protocol<'c>( bc_stage3_gamma, bc_stage4_gamma, bc_stage5_gamma, + booleanity_gamma, inst_ra_gamma, inc_gamma, }, @@ -911,34 +911,6 @@ fn append_transcript_squeeze<'c, 'a>( )) } -fn append_booleanity_power_placeholders<'c, 'a>( - context: &'c MeliorContext, - module: &'a BoltModule<'c, Protocol>, - params: &JoltProtocolParams, - booleanity_gamma: Value<'c, 'a>, -) -> Result<(), MlirError> { - let total = total_ra_oracles(params); - for index in 0..total { - let _ = append_field_pow( - context, - module, - &format!("stage6.booleanity.gamma_sq_{index}"), - booleanity_gamma, - 2 * index, - )?; - } - for index in 0..total { - let _ = append_field_pow( - context, - module, - &format!("stage6.booleanity.gamma_pow_{index}"), - booleanity_gamma, - index, - )?; - } - Ok(()) -} - fn append_stage6_batched_sumcheck<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, @@ -1212,11 +1184,13 @@ fn append_stage6_batched_sumcheck<'c, 'a>( module, params, inputs, + booleanity, hamming, ram, instruction, inc, &output_evals, + spec.booleanity_gamma, spec.inst_ra_gamma, spec.inc_gamma, )?; @@ -1444,6 +1418,7 @@ fn append_stage6_output_openings<'c, 'a>( ) -> Result, MlirError> { let mut claims = Vec::new(); let mut claim_symbols = Vec::new(); + let mut booleanity_ra = Vec::with_capacity(total_ra_oracles(params)); let mut ram_ra = Vec::with_capacity(params.ram_d); let mut instruction_ra = Vec::with_capacity(params.instruction_d); let mut ram_inc = None; @@ -1507,7 +1482,7 @@ fn append_stage6_output_openings<'c, 'a>( let mut eval_index = 0; for index in 0..params.instruction_d { - append_booleanity_output_opening( + booleanity_ra.push(append_booleanity_output_opening( context, module, params, @@ -1516,11 +1491,11 @@ fn append_stage6_output_openings<'c, 'a>( booleanity, &format!("InstructionRa_{index}"), eval_index, - )?; + )?); eval_index += 1; } for index in 0..params.bytecode_d { - append_booleanity_output_opening( + booleanity_ra.push(append_booleanity_output_opening( context, module, params, @@ -1529,11 +1504,11 @@ fn append_stage6_output_openings<'c, 'a>( booleanity, &format!("BytecodeRa_{index}"), eval_index, - )?; + )?); eval_index += 1; } for index in 0..params.ram_d { - append_booleanity_output_opening( + booleanity_ra.push(append_booleanity_output_opening( context, module, params, @@ -1542,7 +1517,7 @@ fn append_stage6_output_openings<'c, 'a>( booleanity, &format!("RamRa_{index}"), eval_index, - )?; + )?); eval_index += 1; } @@ -1714,6 +1689,7 @@ fn append_stage6_output_openings<'c, 'a>( &["!piop.opening_batch_type"], )?; Ok(Stage6OutputEvals { + booleanity_ra, hamming_weight: hamming_eval, ram_ra, instruction_ra, @@ -1728,14 +1704,25 @@ fn append_stage6_output_claims<'c, 'a>( module: &'a BoltModule<'c, Protocol>, params: &JoltProtocolParams, inputs: &Stage6OpeningInputs<'c, 'a>, + booleanity: (Value<'c, 'a>, Value<'c, 'a>), hamming: (Value<'c, 'a>, Value<'c, 'a>), ram: (Value<'c, 'a>, Value<'c, 'a>), instruction: (Value<'c, 'a>, Value<'c, 'a>), inc: (Value<'c, 'a>, Value<'c, 'a>), output_evals: &Stage6OutputEvals<'c, 'a>, + booleanity_gamma: Value<'c, 'a>, instruction_gamma: Value<'c, 'a>, inc_gamma: Value<'c, 'a>, ) -> Result<(), MlirError> { + append_stage6_booleanity_output_claim( + context, + module, + params, + inputs, + booleanity, + output_evals, + booleanity_gamma, + )?; append_stage6_hamming_output_claim(context, module, inputs, hamming, output_evals)?; append_stage6_ram_ra_virtual_output_claim(context, module, inputs, ram, output_evals)?; append_stage6_instruction_ra_virtual_output_claim( @@ -1750,6 +1737,90 @@ fn append_stage6_output_claims<'c, 'a>( append_stage6_inc_output_claim(context, module, inputs, inc, output_evals, inc_gamma) } +fn append_stage6_booleanity_output_claim<'c, 'a>( + context: &'c MeliorContext, + module: &'a BoltModule<'c, Protocol>, + params: &JoltProtocolParams, + inputs: &Stage6OpeningInputs<'c, 'a>, + booleanity: (Value<'c, 'a>, Value<'c, 'a>), + output_evals: &Stage6OutputEvals<'c, 'a>, + gamma: Value<'c, 'a>, +) -> Result<(), MlirError> { + let instruction_ra0 = inputs + .instruction_ra_virtual + .first() + .ok_or_else(|| schema_error("stage6 Booleanity output requires InstructionRa_0 input"))?; + let address = append_point_slice( + context, + module, + "stage6.booleanity.output.point.Address", + "stage6.input.stage5.instruction_read_raf.InstructionRa_0", + 0, + params.log_k_chunk, + instruction_ra0.point, + )?; + let cycle = append_point_slice( + context, + module, + "stage6.booleanity.output.point.Cycle", + "stage6.input.stage5.instruction_read_raf.InstructionRa_0", + params.lookups_ra_virtual_log_k_chunk, + params.log_t, + instruction_ra0.point, + )?; + let expected_point = append_point_concat( + context, + module, + "stage6.booleanity.output.point", + "address_prefix_then_cycle", + booleanity_rounds(params), + &[address, cycle], + )?; + let eq = append_structured_polynomial_eval( + context, + module, + StructuredPolynomialSpec { + symbol: "stage6.booleanity.output.eq.InstructionRa0", + polynomial: "eq", + x_point: StructuredPolynomialPointSpec::full("as_is"), + y_point: StructuredPolynomialPointSpec::full("as_is"), + }, + booleanity.0, + expected_point, + )?; + let family_terms = output_evals + .booleanity_ra + .iter() + .enumerate() + .map(|(index, (symbol, eval))| OutputFunctionFamilyTermSpec { + gamma_power_offset: 2 * index, + function: "boolean_zero", + eval: (symbol.clone(), *eval), + factors: vec![("stage6.booleanity.output.eq.InstructionRa0".to_owned(), eq)], + }) + .collect::>(); + let claim = append_sumcheck_output_function_family( + context, + module, + OutputFunctionFamilySpec { + symbol: "stage6.booleanity.output.family", + }, + Some(("stage6.booleanity.gamma", gamma)), + &family_terms, + )?; + append_sumcheck_output_claim( + context, + module, + OutputClaimSpec { + symbol: "stage6.booleanity.output.claim", + stage: "stage6", + relation: "jolt.stage6.booleanity", + }, + claim, + &[("stage6.booleanity.output.eq.InstructionRa0", eq)], + ) +} + fn append_stage6_hamming_output_claim<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, @@ -2059,12 +2130,13 @@ fn append_booleanity_output_opening<'c, 'a>( booleanity: (Value<'c, 'a>, Value<'c, 'a>), oracle: &str, eval_index: usize, -) -> Result<(), MlirError> { +) -> Result<(String, Value<'c, 'a>), MlirError> { let symbol = format!("stage6.booleanity.opening.{oracle}"); + let eval_symbol = format!("stage6.booleanity.eval.{oracle}"); let eval = append_sumcheck_eval( context, module, - &format!("stage6.booleanity.eval.{oracle}"), + &eval_symbol, "stage6.sumcheck", oracle, eval_index, @@ -2084,7 +2156,7 @@ fn append_booleanity_output_opening<'c, 'a>( claim_kind: "committed", }, )?); - Ok(()) + Ok((eval_symbol, eval)) } fn append_field_zero<'c, 'a>( @@ -2576,6 +2648,7 @@ struct Stage6BatchedSumcheckInputs<'c, 'a, 'b> { bc_stage3_gamma: Value<'c, 'a>, bc_stage4_gamma: Value<'c, 'a>, bc_stage5_gamma: Value<'c, 'a>, + booleanity_gamma: Value<'c, 'a>, inst_ra_gamma: Value<'c, 'a>, inc_gamma: Value<'c, 'a>, } @@ -2592,6 +2665,7 @@ struct Stage6OpeningInputs<'c, 'a> { } struct Stage6OutputEvals<'c, 'a> { + booleanity_ra: Vec<(String, Value<'c, 'a>)>, hamming_weight: Value<'c, 'a>, ram_ra: Vec>, instruction_ra: Vec>, diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 1b3c5cb4a5..3a7784cc1d 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -12,8 +12,8 @@ //! - point normalizations for the Jolt bytecode and instruction RA //! read-RAF lookup arguments //! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement -//! - the remaining `expected_stage67_*` relation evaluators for Stage 6 -//! booleanity and bytecode-read-RAF relations +//! - the remaining `expected_stage67_*` relation evaluator for the Stage 6 +//! bytecode-read-RAF relation //! - the small Jolt-specific field-math helpers //! (`operand_polynomial_eval`, `identity_polynomial_eval`, //! `lt_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt @@ -26,7 +26,7 @@ //! //! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition. -use jolt_field::{Field, Fr, MulPow2, RingCore}; +use jolt_field::{Field, Fr, MulPow2}; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ @@ -86,13 +86,6 @@ pub fn normalize_instruction_read_raf_point( #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage67RelationSymbols { pub hamming_booleanity_instance: &'static str, - pub booleanity_point: &'static str, - pub stage5_instruction_ra0: &'static str, - pub booleanity_combined_point: &'static str, - pub booleanity_gamma: &'static str, - pub booleanity_instruction_ra_prefix: &'static str, - pub booleanity_bytecode_ra_prefix: &'static str, - pub booleanity_ram_ra_prefix: &'static str, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -198,83 +191,6 @@ pub fn expected_stage67_bytecode_read_raf( Ok((val + entry_contrib) * bytecode_ra) } -pub fn expected_stage67_booleanity( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - log_t: usize, - symbols: &Stage67RelationSymbols, -) -> Result { - let log_k_chunk = - local_point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.booleanity_point, - expected: log_t, - actual: local_point.len(), - })?; - let stage5_point = store_point(store, symbols.stage5_instruction_ra0)?; - let stage5_address_len = - stage5_point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.stage5_instruction_ra0, - expected: log_t, - actual: stage5_point.len(), - })?; - if stage5_address_len < log_k_chunk { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.stage5_instruction_ra0, - expected: log_k_chunk + log_t, - actual: stage5_point.len(), - }); - } - - let mut stage5_addr = stage5_point[..stage5_address_len].to_vec(); - stage5_addr.reverse(); - let mut combined_r = stage5_addr[stage5_address_len - log_k_chunk..].to_vec(); - combined_r.extend(stage5_point[stage5_address_len..].iter().rev().copied()); - if combined_r.len() != local_point.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.booleanity_combined_point, - expected: local_point.len(), - actual: combined_r.len(), - }); - } - let mut verifier_point = combined_r[..log_k_chunk].to_vec(); - verifier_point.reverse(); - verifier_point.extend(combined_r[log_k_chunk..].iter().rev().copied()); - let eq_eval = EqPolynomial::::mle(local_point, &verifier_point); - - let gamma = store_scalar(store, symbols.booleanity_gamma)?; - let gamma_sq = gamma.square(); - let mut gamma_power = Fr::from_u64(1); - let mut booleanity = Fr::from_u64(0); - for ra in stage67_booleanity_evals(evals, symbols)? { - booleanity += gamma_power * (ra.square() - ra); - gamma_power *= gamma_sq; - } - Ok(eq_eval * booleanity) -} - -fn stage67_booleanity_evals( - evals: &[StageNamedEval], - symbols: &Stage67RelationSymbols, -) -> Result, RuntimePlanError> { - let mut values = indexed_evals_by_prefix_any(evals, symbols.booleanity_instruction_ra_prefix)?; - values.extend(indexed_evals_by_prefix_any( - evals, - symbols.booleanity_bytecode_ra_prefix, - )?); - values.extend(indexed_evals_by_prefix_any( - evals, - symbols.booleanity_ram_ra_prefix, - )?); - Ok(values) -} - fn stage67_bytecode_stage_cycle_points( store: &ValueStore, log_t: usize, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 5bebdd5e07..5f7ef8f715 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -903,7 +903,6 @@ fn jolt_stage6_protocol_defines_bytecode_booleanity_and_virtualization_flow() { assert!(text.contains("sym_name = \"stage6.booleanity.gamma\"")); assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.gamma\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.gamma\"")); - assert!(text.contains("sym_name = \"stage6.booleanity.gamma_sq_0\"")); assert!(text.contains("source_claim = @stage2.ram_read_write.opening.RamInc")); assert!(text.contains("source_claim = @stage4.registers_read_write.opening.RdInc")); assert!(text.contains("source_claim = @stage5.registers_val_evaluation.opening.RdInc")); @@ -916,10 +915,12 @@ fn jolt_stage6_protocol_defines_bytecode_booleanity_and_virtualization_flow() { assert!(text.contains("@stage6.instruction_ra_virtual.opening.InstructionRa_0")); assert!(text.contains("@stage6.inc_claim_reduction.opening.RamInc")); assert!(text.contains("@stage6.inc_claim_reduction.opening.RdInc")); + assert!(text.contains("sym_name = \"stage6.booleanity.output.claim\"")); assert!(text.contains("sym_name = \"stage6.hamming_booleanity.output.claim\"")); assert!(text.contains("sym_name = \"stage6.ram_ra_virtual.output.claim\"")); assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.output.claim\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.claim\"")); + assert!(text.contains("sym_name = \"stage6.booleanity.output.family\"")); assert!(text.contains("sym_name = \"stage6.hamming_booleanity.output.family\"")); assert!(text.contains("sym_name = \"stage6.ram_ra_virtual.output.family\"")); assert!(text.contains("sym_name = \"stage6.instruction_ra_virtual.output.family\"")); @@ -928,6 +929,7 @@ fn jolt_stage6_protocol_defines_bytecode_booleanity_and_virtualization_flow() { assert!(text.contains("\"piop.sumcheck_output_product_family\"")); assert!(text.contains("\"piop.sumcheck_output_eval_family\"")); assert!(text.contains("sym_name = \"stage6.inc_claim_reduction.output.eq.RdIncStage5\"")); + assert!(text.contains("sym_name = \"stage6.booleanity.output.eq.InstructionRa0\"")); assert!(!text.contains("kernel = @")); assert!(!text.contains("\"compute.")); } @@ -1524,13 +1526,49 @@ fn stage6_rust_targets_extract_and_compile() { + params.instruction_d + 2 ); - assert_eq!(prover_program.output_values.len(), 7); + assert_eq!(prover_program.output_values.len(), 8); assert!(prover_program.output_claims.is_empty()); - assert_eq!(verifier_program.output_values.len(), 7); + assert_eq!(verifier_program.output_values.len(), 8); assert_eq!(verifier_program.output_families.len(), 1); assert_eq!(verifier_program.output_product_families.len(), 2); - assert_eq!(verifier_program.output_function_families.len(), 1); - assert_eq!(verifier_program.output_claims.len(), 4); + assert_eq!(verifier_program.output_function_families.len(), 2); + assert_eq!(verifier_program.output_claims.len(), 5); + let total_booleanity_ra = params.instruction_d + params.bytecode_d + params.ram_d; + let booleanity_function_families = verifier_program + .output_function_families + .iter() + .filter(|family| family.symbol == "stage6.booleanity.output.family") + .collect::>(); + assert_eq!(booleanity_function_families.len(), 1); + let booleanity_function_family = booleanity_function_families[0]; + assert_eq!( + booleanity_function_family.gamma, + Some("stage6.booleanity.gamma".to_owned()) + ); + assert_eq!(booleanity_function_family.terms.len(), total_booleanity_ra); + assert_eq!(booleanity_function_family.terms[0].gamma_power_offset, 0); + assert_eq!(booleanity_function_family.terms[1].gamma_power_offset, 2); + assert_eq!( + booleanity_function_family.terms[total_booleanity_ra - 1].gamma_power_offset, + 2 * (total_booleanity_ra - 1) + ); + assert_eq!(booleanity_function_family.terms[0].function, "boolean_zero"); + assert_eq!( + booleanity_function_family.terms[0].eval, + "stage6.booleanity.eval.InstructionRa_0" + ); + assert_eq!( + booleanity_function_family.terms[params.instruction_d].eval, + "stage6.booleanity.eval.BytecodeRa_0" + ); + assert_eq!( + booleanity_function_family.terms[params.instruction_d + params.bytecode_d].eval, + "stage6.booleanity.eval.RamRa_0" + ); + assert_eq!( + booleanity_function_family.terms[0].factors, + vec!["stage6.booleanity.output.eq.InstructionRa0".to_owned()] + ); let hamming_function_families = verifier_program .output_function_families .iter() @@ -1644,6 +1682,22 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(inc_claims[0].eval_families, vec![inc_family.clone()]); assert!(inc_claims[0].product_families.is_empty()); assert!(inc_claims[0].function_families.is_empty()); + let booleanity_claims = verifier_program + .output_claims + .iter() + .filter(|claim| claim.claim_value == "stage6.booleanity.output.family") + .collect::>(); + assert_eq!(booleanity_claims.len(), 1); + assert!(booleanity_claims[0].eval_families.is_empty()); + assert!(booleanity_claims[0].product_families.is_empty()); + assert_eq!( + booleanity_claims[0].function_families, + vec![booleanity_function_family.clone()] + ); + assert_eq!( + booleanity_claims[0].polynomial_evals[0].symbol, + "stage6.booleanity.output.eq.InstructionRa0" + ); let hamming_claims = verifier_program .output_claims .iter() @@ -1683,11 +1737,11 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(prover_program.point_zeros.len(), 1); assert_eq!( prover_program.point_slices.len(), - params.bytecode_d + 1 + params.ram_d + params.instruction_d + params.bytecode_d + 3 + params.ram_d + params.instruction_d ); assert_eq!( prover_program.point_concats.len(), - params.bytecode_d + 1 + params.ram_d + params.instruction_d + params.bytecode_d + 2 + params.ram_d + params.instruction_d ); assert_eq!( prover_program.opening_claims.len(), @@ -1757,13 +1811,19 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("stage6.bytecode_read_raf.data")); - assert!(verifier_source.source.contains("expected_booleanity")); + assert!(!verifier_source.source.contains("expected_booleanity")); assert!(!verifier_source .source .contains("expected_hamming_booleanity")); assert!(verifier_source .source .contains("expected_plan_output_claim")); + assert!(verifier_source + .source + .contains("stage6.booleanity.output.eq.InstructionRa0")); + assert!(verifier_source + .source + .contains("stage6.booleanity.output.family")); assert!(verifier_source .source .contains("stage6.hamming_booleanity.output.eq.LookupOutput")); @@ -1791,16 +1851,25 @@ fn stage6_rust_targets_extract_and_compile() { .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES")); assert!(verifier_source .source - .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES")); + .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES")); assert!(verifier_source .source .contains("SumcheckOutputProductFamilyPlan")); assert!(verifier_source .source - .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILIES")); + .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES")); assert!(verifier_source .source - .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES")); + .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES")); + assert!(verifier_source + .source + .contains("stage6.booleanity.output.family")); + assert!(verifier_source + .source + .contains("stage6.booleanity.output.eq.InstructionRa0")); + assert!(!verifier_source + .source + .contains("stage6.booleanity.output.gamma_sq_")); assert!(verifier_source .source .contains("stage6.hamming_booleanity.output.family")); diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 1c39b4b56c..4fb644c606 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -398,6 +398,7 @@ fn stage67_output_plan_cutover_removed_obsolete_relation_helpers() { for path in relation_sources { let source = std::fs::read_to_string(&path).expect("read Jolt relation source"); for stale in [ + "expected_stage67_booleanity", "expected_stage67_hamming_booleanity", "expected_stage67_ram_ra_virtual", "expected_stage67_instruction_ra_virtual", @@ -415,6 +416,12 @@ fn stage67_output_plan_cutover_removed_obsolete_relation_helpers() { std::fs::read_to_string(root.join("crates/jolt-verifier/src/stages/stage6.rs")) .expect("read generated Stage 6 verifier source"); for stale_field in [ + "booleanity_point", + "stage5_instruction_ra0", + "booleanity_combined_point", + "booleanity_instruction_ra_prefix", + "booleanity_bytecode_ra_prefix", + "booleanity_ram_ra_prefix", "hamming_weight_eval", "hamming_lookup_output", "ram_ra_virtual_cycle", diff --git a/crates/jolt-prover/src/stages/stage6.rs b/crates/jolt-prover/src/stages/stage6.rs index 37c8c578a3..3165c447dc 100644 --- a/crates/jolt-prover/src/stages/stage6.rs +++ b/crates/jolt-prover/src/stages/stage6.rs @@ -134,1613 +134,1533 @@ pub const STAGE6_FIELD_CONSTANTS: &[Stage6FieldConstantPlan] = &[ Stage6FieldConstantPlan { symbol: "stage6.zero", field: "bn254_fr", value: 0 }, ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_0: &[&str] = &["stage6.booleanity.gamma"]; +pub const STAGE6_FIELD_EXPR_OPERANDS_0: &[&str] = &["stage6.bytecode_read_raf.stage1_gamma"]; -pub const STAGE6_FIELD_EXPR_OPERANDS_1: &[&str] = &["stage6.bytecode_read_raf.stage1_gamma"]; - -pub const STAGE6_FIELD_EXPR_OPERANDS_2: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_1: &[&str] = &[ "stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", "stage6.input.stage1.Imm", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_3: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_2: &[&str] = &[ "stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", "stage6.input.stage1.OpFlagAddOperands", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_4: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_3: &[&str] = &[ "stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", "stage6.input.stage1.OpFlagSubtractOperands", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_5: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_4: &[&str] = &[ "stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", "stage6.input.stage1.OpFlagMultiplyOperands", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_6: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_5: &[&str] = &[ "stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", "stage6.input.stage1.OpFlagLoad", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_7: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_6: &[&str] = &[ "stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", "stage6.input.stage1.OpFlagStore", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_8: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_7: &[&str] = &[ "stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", "stage6.input.stage1.OpFlagJump", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_9: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_8: &[&str] = &[ "stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", "stage6.input.stage1.OpFlagWriteLookupOutputToRD", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_10: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_9: &[&str] = &[ "stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", "stage6.input.stage1.OpFlagVirtualInstruction", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_11: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_10: &[&str] = &[ "stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", "stage6.input.stage1.OpFlagAssert", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_12: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_11: &[&str] = &[ "stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_13: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_12: &[&str] = &[ "stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", "stage6.input.stage1.OpFlagAdvice", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_14: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_13: &[&str] = &[ "stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", "stage6.input.stage1.OpFlagIsCompressed", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_15: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_14: &[&str] = &[ "stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", "stage6.input.stage1.OpFlagIsFirstInSequence", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_16: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_15: &[&str] = &[ "stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", "stage6.input.stage1.OpFlagIsLastInSequence", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_17: &[&str] = &["stage6.bytecode_read_raf.gamma"]; +pub const STAGE6_FIELD_EXPR_OPERANDS_16: &[&str] = &["stage6.bytecode_read_raf.gamma"]; -pub const STAGE6_FIELD_EXPR_OPERANDS_18: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_17: &[&str] = &[ "stage6.bytecode_read_raf.claim.term16.gamma_pow", "stage6.input.stage2.OpFlagJump", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_19: &[&str] = &["stage6.bytecode_read_raf.stage2_gamma"]; +pub const STAGE6_FIELD_EXPR_OPERANDS_18: &[&str] = &["stage6.bytecode_read_raf.stage2_gamma"]; -pub const STAGE6_FIELD_EXPR_OPERANDS_20: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_19: &[&str] = &[ "stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", "stage6.input.stage2.InstructionFlagBranch", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_21: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_20: &[&str] = &[ "stage6.bytecode_read_raf.claim.term17.gamma_pow", "stage6.bytecode_read_raf.claim.term17.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_22: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_21: &[&str] = &[ "stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", "stage6.input.stage2.OpFlagWriteLookupOutputToRD", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_23: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_22: &[&str] = &[ "stage6.bytecode_read_raf.claim.term18.gamma_pow", "stage6.bytecode_read_raf.claim.term18.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_24: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_23: &[&str] = &[ "stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", "stage6.input.stage2.OpFlagVirtualInstruction", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_25: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_24: &[&str] = &[ "stage6.bytecode_read_raf.claim.term19.gamma_pow", "stage6.bytecode_read_raf.claim.term19.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_26: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_25: &[&str] = &[ "stage6.bytecode_read_raf.claim.term20.gamma_pow", "stage6.input.stage3.instruction_input.Imm", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_27: &[&str] = &["stage6.bytecode_read_raf.stage3_gamma"]; +pub const STAGE6_FIELD_EXPR_OPERANDS_26: &[&str] = &["stage6.bytecode_read_raf.stage3_gamma"]; -pub const STAGE6_FIELD_EXPR_OPERANDS_28: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_27: &[&str] = &[ "stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", "stage6.input.stage3.spartan_shift.UnexpandedPC", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_29: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_28: &[&str] = &[ "stage6.bytecode_read_raf.claim.term21.gamma_pow", "stage6.bytecode_read_raf.claim.term21.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_30: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_29: &[&str] = &[ "stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_31: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_30: &[&str] = &[ "stage6.bytecode_read_raf.claim.term22.gamma_pow", "stage6.bytecode_read_raf.claim.term22.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_32: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_31: &[&str] = &[ "stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_33: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_32: &[&str] = &[ "stage6.bytecode_read_raf.claim.term23.gamma_pow", "stage6.bytecode_read_raf.claim.term23.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_34: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_33: &[&str] = &[ "stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_35: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_34: &[&str] = &[ "stage6.bytecode_read_raf.claim.term24.gamma_pow", "stage6.bytecode_read_raf.claim.term24.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_36: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_35: &[&str] = &[ "stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_37: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_36: &[&str] = &[ "stage6.bytecode_read_raf.claim.term25.gamma_pow", "stage6.bytecode_read_raf.claim.term25.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_38: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_37: &[&str] = &[ "stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_39: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_38: &[&str] = &[ "stage6.bytecode_read_raf.claim.term26.gamma_pow", "stage6.bytecode_read_raf.claim.term26.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_40: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_39: &[&str] = &[ "stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_41: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_40: &[&str] = &[ "stage6.bytecode_read_raf.claim.term27.gamma_pow", "stage6.bytecode_read_raf.claim.term27.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_42: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_41: &[&str] = &[ "stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_43: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_42: &[&str] = &[ "stage6.bytecode_read_raf.claim.term28.gamma_pow", "stage6.bytecode_read_raf.claim.term28.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_44: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_43: &[&str] = &[ "stage6.bytecode_read_raf.claim.term29.gamma_pow", "stage6.input.stage4.RdWa", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_45: &[&str] = &["stage6.bytecode_read_raf.stage4_gamma"]; +pub const STAGE6_FIELD_EXPR_OPERANDS_44: &[&str] = &["stage6.bytecode_read_raf.stage4_gamma"]; -pub const STAGE6_FIELD_EXPR_OPERANDS_46: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_45: &[&str] = &[ "stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", "stage6.input.stage4.Rs1Ra", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_47: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_46: &[&str] = &[ "stage6.bytecode_read_raf.claim.term30.gamma_pow", "stage6.bytecode_read_raf.claim.term30.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_48: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_47: &[&str] = &[ "stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", "stage6.input.stage4.Rs2Ra", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_49: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_48: &[&str] = &[ "stage6.bytecode_read_raf.claim.term31.gamma_pow", "stage6.bytecode_read_raf.claim.term31.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_50: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_49: &[&str] = &[ "stage6.bytecode_read_raf.claim.term32.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdWa", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_51: &[&str] = &["stage6.bytecode_read_raf.stage5_gamma"]; +pub const STAGE6_FIELD_EXPR_OPERANDS_50: &[&str] = &["stage6.bytecode_read_raf.stage5_gamma"]; -pub const STAGE6_FIELD_EXPR_OPERANDS_52: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_51: &[&str] = &[ "stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", "stage6.input.stage5.InstructionRafFlag", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_53: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_52: &[&str] = &[ "stage6.bytecode_read_raf.claim.term33.gamma_pow", "stage6.bytecode_read_raf.claim.term33.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_54: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_53: &[&str] = &[ "stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_0", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_55: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_54: &[&str] = &[ "stage6.bytecode_read_raf.claim.term34.gamma_pow", "stage6.bytecode_read_raf.claim.term34.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_56: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_55: &[&str] = &[ "stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_1", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_57: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_56: &[&str] = &[ "stage6.bytecode_read_raf.claim.term35.gamma_pow", "stage6.bytecode_read_raf.claim.term35.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_58: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_57: &[&str] = &[ "stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_2", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_59: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_58: &[&str] = &[ "stage6.bytecode_read_raf.claim.term36.gamma_pow", "stage6.bytecode_read_raf.claim.term36.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_60: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_59: &[&str] = &[ "stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_3", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_61: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_60: &[&str] = &[ "stage6.bytecode_read_raf.claim.term37.gamma_pow", "stage6.bytecode_read_raf.claim.term37.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_62: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_61: &[&str] = &[ "stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_4", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_63: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_62: &[&str] = &[ "stage6.bytecode_read_raf.claim.term38.gamma_pow", "stage6.bytecode_read_raf.claim.term38.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_64: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_63: &[&str] = &[ "stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_5", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_65: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_64: &[&str] = &[ "stage6.bytecode_read_raf.claim.term39.gamma_pow", "stage6.bytecode_read_raf.claim.term39.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_66: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_65: &[&str] = &[ "stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_6", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_67: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_66: &[&str] = &[ "stage6.bytecode_read_raf.claim.term40.gamma_pow", "stage6.bytecode_read_raf.claim.term40.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_68: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_67: &[&str] = &[ "stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_7", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_69: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_68: &[&str] = &[ "stage6.bytecode_read_raf.claim.term41.gamma_pow", "stage6.bytecode_read_raf.claim.term41.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_70: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_69: &[&str] = &[ "stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_8", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_71: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_70: &[&str] = &[ "stage6.bytecode_read_raf.claim.term42.gamma_pow", "stage6.bytecode_read_raf.claim.term42.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_72: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_71: &[&str] = &[ "stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_9", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_73: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_72: &[&str] = &[ "stage6.bytecode_read_raf.claim.term43.gamma_pow", "stage6.bytecode_read_raf.claim.term43.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_74: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_73: &[&str] = &[ "stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_10", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_75: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_74: &[&str] = &[ "stage6.bytecode_read_raf.claim.term44.gamma_pow", "stage6.bytecode_read_raf.claim.term44.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_76: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_75: &[&str] = &[ "stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_11", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_77: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_76: &[&str] = &[ "stage6.bytecode_read_raf.claim.term45.gamma_pow", "stage6.bytecode_read_raf.claim.term45.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_78: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_77: &[&str] = &[ "stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_12", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_79: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_78: &[&str] = &[ "stage6.bytecode_read_raf.claim.term46.gamma_pow", "stage6.bytecode_read_raf.claim.term46.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_80: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_79: &[&str] = &[ "stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_13", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_81: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_80: &[&str] = &[ "stage6.bytecode_read_raf.claim.term47.gamma_pow", "stage6.bytecode_read_raf.claim.term47.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_82: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_81: &[&str] = &[ "stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_14", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_83: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_82: &[&str] = &[ "stage6.bytecode_read_raf.claim.term48.gamma_pow", "stage6.bytecode_read_raf.claim.term48.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_84: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_83: &[&str] = &[ "stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_15", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_85: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_84: &[&str] = &[ "stage6.bytecode_read_raf.claim.term49.gamma_pow", "stage6.bytecode_read_raf.claim.term49.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_86: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_85: &[&str] = &[ "stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_16", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_87: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_86: &[&str] = &[ "stage6.bytecode_read_raf.claim.term50.gamma_pow", "stage6.bytecode_read_raf.claim.term50.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_88: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_87: &[&str] = &[ "stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_17", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_89: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_88: &[&str] = &[ "stage6.bytecode_read_raf.claim.term51.gamma_pow", "stage6.bytecode_read_raf.claim.term51.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_90: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_89: &[&str] = &[ "stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_18", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_91: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_90: &[&str] = &[ "stage6.bytecode_read_raf.claim.term52.gamma_pow", "stage6.bytecode_read_raf.claim.term52.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_92: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_91: &[&str] = &[ "stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_19", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_93: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_92: &[&str] = &[ "stage6.bytecode_read_raf.claim.term53.gamma_pow", "stage6.bytecode_read_raf.claim.term53.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_94: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_93: &[&str] = &[ "stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_20", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_95: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_94: &[&str] = &[ "stage6.bytecode_read_raf.claim.term54.gamma_pow", "stage6.bytecode_read_raf.claim.term54.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_96: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_95: &[&str] = &[ "stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_21", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_97: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_96: &[&str] = &[ "stage6.bytecode_read_raf.claim.term55.gamma_pow", "stage6.bytecode_read_raf.claim.term55.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_98: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_97: &[&str] = &[ "stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_22", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_99: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_98: &[&str] = &[ "stage6.bytecode_read_raf.claim.term56.gamma_pow", "stage6.bytecode_read_raf.claim.term56.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_100: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_99: &[&str] = &[ "stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_23", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_101: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_100: &[&str] = &[ "stage6.bytecode_read_raf.claim.term57.gamma_pow", "stage6.bytecode_read_raf.claim.term57.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_102: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_101: &[&str] = &[ "stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_24", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_103: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_102: &[&str] = &[ "stage6.bytecode_read_raf.claim.term58.gamma_pow", "stage6.bytecode_read_raf.claim.term58.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_104: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_103: &[&str] = &[ "stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_25", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_105: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_104: &[&str] = &[ "stage6.bytecode_read_raf.claim.term59.gamma_pow", "stage6.bytecode_read_raf.claim.term59.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_106: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_105: &[&str] = &[ "stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_26", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_107: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_106: &[&str] = &[ "stage6.bytecode_read_raf.claim.term60.gamma_pow", "stage6.bytecode_read_raf.claim.term60.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_108: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_107: &[&str] = &[ "stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_27", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_109: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_108: &[&str] = &[ "stage6.bytecode_read_raf.claim.term61.gamma_pow", "stage6.bytecode_read_raf.claim.term61.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_110: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_109: &[&str] = &[ "stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_28", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_111: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_110: &[&str] = &[ "stage6.bytecode_read_raf.claim.term62.gamma_pow", "stage6.bytecode_read_raf.claim.term62.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_112: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_111: &[&str] = &[ "stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_29", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_113: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_112: &[&str] = &[ "stage6.bytecode_read_raf.claim.term63.gamma_pow", "stage6.bytecode_read_raf.claim.term63.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_114: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_113: &[&str] = &[ "stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_30", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_115: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_114: &[&str] = &[ "stage6.bytecode_read_raf.claim.term64.gamma_pow", "stage6.bytecode_read_raf.claim.term64.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_116: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_115: &[&str] = &[ "stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_31", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_117: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_116: &[&str] = &[ "stage6.bytecode_read_raf.claim.term65.gamma_pow", "stage6.bytecode_read_raf.claim.term65.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_118: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_117: &[&str] = &[ "stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_32", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_119: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_118: &[&str] = &[ "stage6.bytecode_read_raf.claim.term66.gamma_pow", "stage6.bytecode_read_raf.claim.term66.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_120: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_119: &[&str] = &[ "stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_33", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_121: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_120: &[&str] = &[ "stage6.bytecode_read_raf.claim.term67.gamma_pow", "stage6.bytecode_read_raf.claim.term67.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_122: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_121: &[&str] = &[ "stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_34", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_123: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_122: &[&str] = &[ "stage6.bytecode_read_raf.claim.term68.gamma_pow", "stage6.bytecode_read_raf.claim.term68.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_124: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_123: &[&str] = &[ "stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_35", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_125: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_124: &[&str] = &[ "stage6.bytecode_read_raf.claim.term69.gamma_pow", "stage6.bytecode_read_raf.claim.term69.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_126: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_125: &[&str] = &[ "stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_36", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_127: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_126: &[&str] = &[ "stage6.bytecode_read_raf.claim.term70.gamma_pow", "stage6.bytecode_read_raf.claim.term70.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_128: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_127: &[&str] = &[ "stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_37", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_129: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_128: &[&str] = &[ "stage6.bytecode_read_raf.claim.term71.gamma_pow", "stage6.bytecode_read_raf.claim.term71.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_130: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_129: &[&str] = &[ "stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_38", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_131: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_130: &[&str] = &[ "stage6.bytecode_read_raf.claim.term72.gamma_pow", "stage6.bytecode_read_raf.claim.term72.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_132: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_131: &[&str] = &[ "stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_39", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_133: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_132: &[&str] = &[ "stage6.bytecode_read_raf.claim.term73.gamma_pow", "stage6.bytecode_read_raf.claim.term73.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_134: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_133: &[&str] = &[ "stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_40", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_135: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_134: &[&str] = &[ "stage6.bytecode_read_raf.claim.term74.gamma_pow", "stage6.bytecode_read_raf.claim.term74.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_136: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_135: &[&str] = &[ "stage6.bytecode_read_raf.claim.term75.gamma_pow", "stage6.input.stage1.PC", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_137: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_136: &[&str] = &[ "stage6.bytecode_read_raf.claim.term76.gamma_pow", "stage6.input.stage3.spartan_shift.PC", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_138: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_137: &[&str] = &[ "stage6.input.stage1.UnexpandedPC", "stage6.bytecode_read_raf.claim.term1.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_139: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_138: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial0", "stage6.bytecode_read_raf.claim.term2.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_140: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_139: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial1", "stage6.bytecode_read_raf.claim.term3.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_141: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_140: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial2", "stage6.bytecode_read_raf.claim.term4.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_142: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_141: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial3", "stage6.bytecode_read_raf.claim.term5.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_143: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_142: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial4", "stage6.bytecode_read_raf.claim.term6.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_144: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_143: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial5", "stage6.bytecode_read_raf.claim.term7.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_145: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_144: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial6", "stage6.bytecode_read_raf.claim.term8.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_146: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_145: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial7", "stage6.bytecode_read_raf.claim.term9.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_147: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_146: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial8", "stage6.bytecode_read_raf.claim.term10.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_148: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_147: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial9", "stage6.bytecode_read_raf.claim.term11.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_149: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_148: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial10", "stage6.bytecode_read_raf.claim.term12.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_150: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_149: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial11", "stage6.bytecode_read_raf.claim.term13.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_151: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_150: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial12", "stage6.bytecode_read_raf.claim.term14.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_152: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_151: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial13", "stage6.bytecode_read_raf.claim.term15.stage_gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_153: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_152: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial14", "stage6.bytecode_read_raf.claim.term16.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_154: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_153: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial15", "stage6.bytecode_read_raf.claim.term17.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_155: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_154: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial16", "stage6.bytecode_read_raf.claim.term18.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_156: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_155: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial17", "stage6.bytecode_read_raf.claim.term19.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_157: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_156: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial18", "stage6.bytecode_read_raf.claim.term20.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_158: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_157: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial19", "stage6.bytecode_read_raf.claim.term21.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_159: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_158: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial20", "stage6.bytecode_read_raf.claim.term22.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_160: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_159: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial21", "stage6.bytecode_read_raf.claim.term23.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_161: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_160: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial22", "stage6.bytecode_read_raf.claim.term24.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_162: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_161: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial23", "stage6.bytecode_read_raf.claim.term25.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_163: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_162: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial24", "stage6.bytecode_read_raf.claim.term26.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_164: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_163: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial25", "stage6.bytecode_read_raf.claim.term27.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_165: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_164: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial26", "stage6.bytecode_read_raf.claim.term28.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_166: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_165: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial27", "stage6.bytecode_read_raf.claim.term29.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_167: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_166: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial28", "stage6.bytecode_read_raf.claim.term30.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_168: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_167: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial29", "stage6.bytecode_read_raf.claim.term31.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_169: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_168: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial30", "stage6.bytecode_read_raf.claim.term32.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_170: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_169: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial31", "stage6.bytecode_read_raf.claim.term33.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_171: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_170: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial32", "stage6.bytecode_read_raf.claim.term34.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_172: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_171: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial33", "stage6.bytecode_read_raf.claim.term35.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_173: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_172: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial34", "stage6.bytecode_read_raf.claim.term36.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_174: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_173: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial35", "stage6.bytecode_read_raf.claim.term37.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_175: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_174: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial36", "stage6.bytecode_read_raf.claim.term38.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_176: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_175: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial37", "stage6.bytecode_read_raf.claim.term39.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_177: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_176: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial38", "stage6.bytecode_read_raf.claim.term40.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_178: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_177: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial39", "stage6.bytecode_read_raf.claim.term41.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_179: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_178: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial40", "stage6.bytecode_read_raf.claim.term42.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_180: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_179: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial41", "stage6.bytecode_read_raf.claim.term43.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_181: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_180: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial42", "stage6.bytecode_read_raf.claim.term44.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_182: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_181: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial43", "stage6.bytecode_read_raf.claim.term45.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_183: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_182: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial44", "stage6.bytecode_read_raf.claim.term46.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_184: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_183: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial45", "stage6.bytecode_read_raf.claim.term47.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_185: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_184: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial46", "stage6.bytecode_read_raf.claim.term48.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_186: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_185: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial47", "stage6.bytecode_read_raf.claim.term49.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_187: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_186: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial48", "stage6.bytecode_read_raf.claim.term50.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_188: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_187: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial49", "stage6.bytecode_read_raf.claim.term51.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_189: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_188: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial50", "stage6.bytecode_read_raf.claim.term52.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_190: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_189: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial51", "stage6.bytecode_read_raf.claim.term53.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_191: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_190: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial52", "stage6.bytecode_read_raf.claim.term54.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_192: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_191: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial53", "stage6.bytecode_read_raf.claim.term55.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_193: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_192: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial54", "stage6.bytecode_read_raf.claim.term56.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_194: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_193: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial55", "stage6.bytecode_read_raf.claim.term57.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_195: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_194: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial56", "stage6.bytecode_read_raf.claim.term58.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_196: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_195: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial57", "stage6.bytecode_read_raf.claim.term59.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_197: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_196: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial58", "stage6.bytecode_read_raf.claim.term60.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_198: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_197: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial59", "stage6.bytecode_read_raf.claim.term61.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_199: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_198: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial60", "stage6.bytecode_read_raf.claim.term62.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_200: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_199: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial61", "stage6.bytecode_read_raf.claim.term63.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_201: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_200: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial62", "stage6.bytecode_read_raf.claim.term64.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_202: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_201: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial63", "stage6.bytecode_read_raf.claim.term65.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_203: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_202: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial64", "stage6.bytecode_read_raf.claim.term66.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_204: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_203: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial65", "stage6.bytecode_read_raf.claim.term67.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_205: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_204: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial66", "stage6.bytecode_read_raf.claim.term68.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_206: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_205: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial67", "stage6.bytecode_read_raf.claim.term69.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_207: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_206: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial68", "stage6.bytecode_read_raf.claim.term70.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_208: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_207: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial69", "stage6.bytecode_read_raf.claim.term71.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_209: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_208: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial70", "stage6.bytecode_read_raf.claim.term72.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_210: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_209: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial71", "stage6.bytecode_read_raf.claim.term73.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_211: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_210: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial72", "stage6.bytecode_read_raf.claim.term74.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_212: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_211: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial73", "stage6.bytecode_read_raf.claim.term75.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_213: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_212: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial74", "stage6.bytecode_read_raf.claim.term76.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_214: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_213: &[&str] = &[ "stage6.bytecode_read_raf.claim_expr.partial75", "stage6.bytecode_read_raf.claim.entry_constant", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_215: &[&str] = &["stage6.instruction_ra_virtual.gamma"]; +pub const STAGE6_FIELD_EXPR_OPERANDS_214: &[&str] = &["stage6.instruction_ra_virtual.gamma"]; -pub const STAGE6_FIELD_EXPR_OPERANDS_216: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_215: &[&str] = &[ "stage6.instruction_ra_virtual.claim.term1.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_1", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_217: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_216: &[&str] = &[ "stage6.instruction_ra_virtual.claim.term2.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_2", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_218: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_217: &[&str] = &[ "stage6.instruction_ra_virtual.claim.term3.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_3", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_219: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_218: &[&str] = &[ "stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_220: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_219: &[&str] = &[ "stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_221: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_220: &[&str] = &[ "stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_222: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_221: &[&str] = &[ "stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_223: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_222: &[&str] = &[ "stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_224: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_223: &[&str] = &[ "stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_225: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_224: &[&str] = &[ "stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_226: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_225: &[&str] = &[ "stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_227: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_226: &[&str] = &[ "stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_228: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_227: &[&str] = &[ "stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_229: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_228: &[&str] = &[ "stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_230: &[&str] = &["stage6.inc_claim_reduction.gamma"]; +pub const STAGE6_FIELD_EXPR_OPERANDS_229: &[&str] = &["stage6.inc_claim_reduction.gamma"]; -pub const STAGE6_FIELD_EXPR_OPERANDS_231: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_230: &[&str] = &[ "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_232: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_231: &[&str] = &[ "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_233: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_232: &[&str] = &[ "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_234: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_233: &[&str] = &[ "stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_235: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_234: &[&str] = &[ "stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", ]; -pub const STAGE6_FIELD_EXPR_OPERANDS_236: &[&str] = &[ +pub const STAGE6_FIELD_EXPR_OPERANDS_235: &[&str] = &[ "stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", ]; pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_0", kind: "op", formula: "field.pow:0", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_1", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_2", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_3", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_4", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_5", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_6", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_7", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_8", kind: "op", formula: "field.pow:16", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_9", kind: "op", formula: "field.pow:18", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_10", kind: "op", formula: "field.pow:20", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_11", kind: "op", formula: "field.pow:22", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_12", kind: "op", formula: "field.pow:24", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_13", kind: "op", formula: "field.pow:26", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_14", kind: "op", formula: "field.pow:28", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_15", kind: "op", formula: "field.pow:30", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_16", kind: "op", formula: "field.pow:32", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_17", kind: "op", formula: "field.pow:34", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_18", kind: "op", formula: "field.pow:36", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_19", kind: "op", formula: "field.pow:38", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_20", kind: "op", formula: "field.pow:40", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_21", kind: "op", formula: "field.pow:42", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_22", kind: "op", formula: "field.pow:44", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_23", kind: "op", formula: "field.pow:46", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_24", kind: "op", formula: "field.pow:48", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_25", kind: "op", formula: "field.pow:50", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_26", kind: "op", formula: "field.pow:52", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_27", kind: "op", formula: "field.pow:54", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_28", kind: "op", formula: "field.pow:56", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_29", kind: "op", formula: "field.pow:58", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_30", kind: "op", formula: "field.pow:60", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_31", kind: "op", formula: "field.pow:62", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_32", kind: "op", formula: "field.pow:64", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_33", kind: "op", formula: "field.pow:66", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_34", kind: "op", formula: "field.pow:68", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_35", kind: "op", formula: "field.pow:70", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_36", kind: "op", formula: "field.pow:72", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_37", kind: "op", formula: "field.pow:74", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_sq_38", kind: "op", formula: "field.pow:76", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_0", kind: "op", formula: "field.pow:0", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_1", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_2", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_3", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_4", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_5", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_6", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_7", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_8", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_9", kind: "op", formula: "field.pow:9", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_10", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_11", kind: "op", formula: "field.pow:11", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_12", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_13", kind: "op", formula: "field.pow:13", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_14", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_15", kind: "op", formula: "field.pow:15", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_16", kind: "op", formula: "field.pow:16", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_17", kind: "op", formula: "field.pow:17", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_18", kind: "op", formula: "field.pow:18", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_19", kind: "op", formula: "field.pow:19", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_20", kind: "op", formula: "field.pow:20", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_21", kind: "op", formula: "field.pow:21", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_22", kind: "op", formula: "field.pow:22", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_23", kind: "op", formula: "field.pow:23", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_24", kind: "op", formula: "field.pow:24", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_25", kind: "op", formula: "field.pow:25", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_26", kind: "op", formula: "field.pow:26", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_27", kind: "op", formula: "field.pow:27", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_28", kind: "op", formula: "field.pow:28", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_29", kind: "op", formula: "field.pow:29", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_30", kind: "op", formula: "field.pow:30", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_31", kind: "op", formula: "field.pow:31", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_32", kind: "op", formula: "field.pow:32", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_33", kind: "op", formula: "field.pow:33", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_34", kind: "op", formula: "field.pow:34", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_35", kind: "op", formula: "field.pow:35", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_36", kind: "op", formula: "field.pow:36", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_37", kind: "op", formula: "field.pow:37", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.booleanity.gamma_pow_38", kind: "op", formula: "field.pow:38", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term1.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_2, operands: STAGE6_FIELD_EXPR_OPERANDS_2 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term2.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_3, operands: STAGE6_FIELD_EXPR_OPERANDS_3 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term3.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_4, operands: STAGE6_FIELD_EXPR_OPERANDS_4 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term4.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_5, operands: STAGE6_FIELD_EXPR_OPERANDS_5 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term5.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_6, operands: STAGE6_FIELD_EXPR_OPERANDS_6 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term6.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_7, operands: STAGE6_FIELD_EXPR_OPERANDS_7 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term7.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_8, operands: STAGE6_FIELD_EXPR_OPERANDS_8 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term8.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_9, operands: STAGE6_FIELD_EXPR_OPERANDS_9 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", kind: "op", formula: "field.pow:9", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term9.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_10, operands: STAGE6_FIELD_EXPR_OPERANDS_10 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term10.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_11, operands: STAGE6_FIELD_EXPR_OPERANDS_11 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", kind: "op", formula: "field.pow:11", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term11.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_12, operands: STAGE6_FIELD_EXPR_OPERANDS_12 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term12.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_13, operands: STAGE6_FIELD_EXPR_OPERANDS_13 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", kind: "op", formula: "field.pow:13", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term13.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_14, operands: STAGE6_FIELD_EXPR_OPERANDS_14 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term14.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_15, operands: STAGE6_FIELD_EXPR_OPERANDS_15 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", kind: "op", formula: "field.pow:15", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term15.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term16.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term16.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_18, operands: STAGE6_FIELD_EXPR_OPERANDS_18 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_19, operands: STAGE6_FIELD_EXPR_OPERANDS_19 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_20, operands: STAGE6_FIELD_EXPR_OPERANDS_20 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_21, operands: STAGE6_FIELD_EXPR_OPERANDS_21 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_19, operands: STAGE6_FIELD_EXPR_OPERANDS_19 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_22, operands: STAGE6_FIELD_EXPR_OPERANDS_22 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_23, operands: STAGE6_FIELD_EXPR_OPERANDS_23 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_19, operands: STAGE6_FIELD_EXPR_OPERANDS_19 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_24, operands: STAGE6_FIELD_EXPR_OPERANDS_24 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_25, operands: STAGE6_FIELD_EXPR_OPERANDS_25 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term20.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term20.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_28, operands: STAGE6_FIELD_EXPR_OPERANDS_28 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_29, operands: STAGE6_FIELD_EXPR_OPERANDS_29 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_30, operands: STAGE6_FIELD_EXPR_OPERANDS_30 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_31, operands: STAGE6_FIELD_EXPR_OPERANDS_31 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_32, operands: STAGE6_FIELD_EXPR_OPERANDS_32 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_33, operands: STAGE6_FIELD_EXPR_OPERANDS_33 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_34, operands: STAGE6_FIELD_EXPR_OPERANDS_34 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_35, operands: STAGE6_FIELD_EXPR_OPERANDS_35 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_36, operands: STAGE6_FIELD_EXPR_OPERANDS_36 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_37, operands: STAGE6_FIELD_EXPR_OPERANDS_37 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_38, operands: STAGE6_FIELD_EXPR_OPERANDS_38 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_39, operands: STAGE6_FIELD_EXPR_OPERANDS_39 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_40, operands: STAGE6_FIELD_EXPR_OPERANDS_40 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_41, operands: STAGE6_FIELD_EXPR_OPERANDS_41 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_42, operands: STAGE6_FIELD_EXPR_OPERANDS_42 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_43, operands: STAGE6_FIELD_EXPR_OPERANDS_43 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term29.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term29.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_44, operands: STAGE6_FIELD_EXPR_OPERANDS_44 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_45, operands: STAGE6_FIELD_EXPR_OPERANDS_45 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_46, operands: STAGE6_FIELD_EXPR_OPERANDS_46 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_47, operands: STAGE6_FIELD_EXPR_OPERANDS_47 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_45, operands: STAGE6_FIELD_EXPR_OPERANDS_45 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_48, operands: STAGE6_FIELD_EXPR_OPERANDS_48 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_49, operands: STAGE6_FIELD_EXPR_OPERANDS_49 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term32.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term32.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_52, operands: STAGE6_FIELD_EXPR_OPERANDS_52 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_53, operands: STAGE6_FIELD_EXPR_OPERANDS_53 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_54, operands: STAGE6_FIELD_EXPR_OPERANDS_54 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_55, operands: STAGE6_FIELD_EXPR_OPERANDS_55 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_56, operands: STAGE6_FIELD_EXPR_OPERANDS_56 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_57, operands: STAGE6_FIELD_EXPR_OPERANDS_57 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_58, operands: STAGE6_FIELD_EXPR_OPERANDS_58 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_59, operands: STAGE6_FIELD_EXPR_OPERANDS_59 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_60, operands: STAGE6_FIELD_EXPR_OPERANDS_60 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_61, operands: STAGE6_FIELD_EXPR_OPERANDS_61 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_62, operands: STAGE6_FIELD_EXPR_OPERANDS_62 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_63, operands: STAGE6_FIELD_EXPR_OPERANDS_63 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_64, operands: STAGE6_FIELD_EXPR_OPERANDS_64 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_65, operands: STAGE6_FIELD_EXPR_OPERANDS_65 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_66, operands: STAGE6_FIELD_EXPR_OPERANDS_66 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_67, operands: STAGE6_FIELD_EXPR_OPERANDS_67 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", kind: "op", formula: "field.pow:9", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_68, operands: STAGE6_FIELD_EXPR_OPERANDS_68 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_69, operands: STAGE6_FIELD_EXPR_OPERANDS_69 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_70, operands: STAGE6_FIELD_EXPR_OPERANDS_70 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_71, operands: STAGE6_FIELD_EXPR_OPERANDS_71 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", kind: "op", formula: "field.pow:11", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_72, operands: STAGE6_FIELD_EXPR_OPERANDS_72 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_73, operands: STAGE6_FIELD_EXPR_OPERANDS_73 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_74, operands: STAGE6_FIELD_EXPR_OPERANDS_74 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_75, operands: STAGE6_FIELD_EXPR_OPERANDS_75 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", kind: "op", formula: "field.pow:13", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_76, operands: STAGE6_FIELD_EXPR_OPERANDS_76 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_77, operands: STAGE6_FIELD_EXPR_OPERANDS_77 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_78, operands: STAGE6_FIELD_EXPR_OPERANDS_78 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_79, operands: STAGE6_FIELD_EXPR_OPERANDS_79 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", kind: "op", formula: "field.pow:15", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_80, operands: STAGE6_FIELD_EXPR_OPERANDS_80 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_81, operands: STAGE6_FIELD_EXPR_OPERANDS_81 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", kind: "op", formula: "field.pow:16", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_82, operands: STAGE6_FIELD_EXPR_OPERANDS_82 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_83, operands: STAGE6_FIELD_EXPR_OPERANDS_83 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", kind: "op", formula: "field.pow:17", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_84, operands: STAGE6_FIELD_EXPR_OPERANDS_84 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_85, operands: STAGE6_FIELD_EXPR_OPERANDS_85 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", kind: "op", formula: "field.pow:18", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_86, operands: STAGE6_FIELD_EXPR_OPERANDS_86 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_87, operands: STAGE6_FIELD_EXPR_OPERANDS_87 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", kind: "op", formula: "field.pow:19", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_88, operands: STAGE6_FIELD_EXPR_OPERANDS_88 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_89, operands: STAGE6_FIELD_EXPR_OPERANDS_89 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", kind: "op", formula: "field.pow:20", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_90, operands: STAGE6_FIELD_EXPR_OPERANDS_90 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_91, operands: STAGE6_FIELD_EXPR_OPERANDS_91 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", kind: "op", formula: "field.pow:21", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_92, operands: STAGE6_FIELD_EXPR_OPERANDS_92 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_93, operands: STAGE6_FIELD_EXPR_OPERANDS_93 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", kind: "op", formula: "field.pow:22", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_94, operands: STAGE6_FIELD_EXPR_OPERANDS_94 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_95, operands: STAGE6_FIELD_EXPR_OPERANDS_95 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", kind: "op", formula: "field.pow:23", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_96, operands: STAGE6_FIELD_EXPR_OPERANDS_96 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_97, operands: STAGE6_FIELD_EXPR_OPERANDS_97 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", kind: "op", formula: "field.pow:24", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_98, operands: STAGE6_FIELD_EXPR_OPERANDS_98 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_99, operands: STAGE6_FIELD_EXPR_OPERANDS_99 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", kind: "op", formula: "field.pow:25", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_100, operands: STAGE6_FIELD_EXPR_OPERANDS_100 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_101, operands: STAGE6_FIELD_EXPR_OPERANDS_101 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", kind: "op", formula: "field.pow:26", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_102, operands: STAGE6_FIELD_EXPR_OPERANDS_102 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_103, operands: STAGE6_FIELD_EXPR_OPERANDS_103 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", kind: "op", formula: "field.pow:27", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_104, operands: STAGE6_FIELD_EXPR_OPERANDS_104 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_105, operands: STAGE6_FIELD_EXPR_OPERANDS_105 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", kind: "op", formula: "field.pow:28", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_106, operands: STAGE6_FIELD_EXPR_OPERANDS_106 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_107, operands: STAGE6_FIELD_EXPR_OPERANDS_107 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", kind: "op", formula: "field.pow:29", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_108, operands: STAGE6_FIELD_EXPR_OPERANDS_108 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_109, operands: STAGE6_FIELD_EXPR_OPERANDS_109 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", kind: "op", formula: "field.pow:30", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_110, operands: STAGE6_FIELD_EXPR_OPERANDS_110 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_111, operands: STAGE6_FIELD_EXPR_OPERANDS_111 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", kind: "op", formula: "field.pow:31", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_112, operands: STAGE6_FIELD_EXPR_OPERANDS_112 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_113, operands: STAGE6_FIELD_EXPR_OPERANDS_113 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", kind: "op", formula: "field.pow:32", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_114, operands: STAGE6_FIELD_EXPR_OPERANDS_114 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_115, operands: STAGE6_FIELD_EXPR_OPERANDS_115 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", kind: "op", formula: "field.pow:33", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_116, operands: STAGE6_FIELD_EXPR_OPERANDS_116 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_117, operands: STAGE6_FIELD_EXPR_OPERANDS_117 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", kind: "op", formula: "field.pow:34", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_118, operands: STAGE6_FIELD_EXPR_OPERANDS_118 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_119, operands: STAGE6_FIELD_EXPR_OPERANDS_119 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", kind: "op", formula: "field.pow:35", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_120, operands: STAGE6_FIELD_EXPR_OPERANDS_120 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_121, operands: STAGE6_FIELD_EXPR_OPERANDS_121 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", kind: "op", formula: "field.pow:36", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_122, operands: STAGE6_FIELD_EXPR_OPERANDS_122 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_123, operands: STAGE6_FIELD_EXPR_OPERANDS_123 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", kind: "op", formula: "field.pow:37", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_124, operands: STAGE6_FIELD_EXPR_OPERANDS_124 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_125, operands: STAGE6_FIELD_EXPR_OPERANDS_125 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", kind: "op", formula: "field.pow:38", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_126, operands: STAGE6_FIELD_EXPR_OPERANDS_126 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_127, operands: STAGE6_FIELD_EXPR_OPERANDS_127 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", kind: "op", formula: "field.pow:39", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_128, operands: STAGE6_FIELD_EXPR_OPERANDS_128 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_129, operands: STAGE6_FIELD_EXPR_OPERANDS_129 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", kind: "op", formula: "field.pow:40", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_130, operands: STAGE6_FIELD_EXPR_OPERANDS_130 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_131, operands: STAGE6_FIELD_EXPR_OPERANDS_131 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", kind: "op", formula: "field.pow:41", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_132, operands: STAGE6_FIELD_EXPR_OPERANDS_132 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_133, operands: STAGE6_FIELD_EXPR_OPERANDS_133 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", kind: "op", formula: "field.pow:42", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_134, operands: STAGE6_FIELD_EXPR_OPERANDS_134 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_135, operands: STAGE6_FIELD_EXPR_OPERANDS_135 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term75.gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term75.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_136, operands: STAGE6_FIELD_EXPR_OPERANDS_136 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term76.gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term76.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_137, operands: STAGE6_FIELD_EXPR_OPERANDS_137 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.entry_constant", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_138, operands: STAGE6_FIELD_EXPR_OPERANDS_138 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_139, operands: STAGE6_FIELD_EXPR_OPERANDS_139 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_140, operands: STAGE6_FIELD_EXPR_OPERANDS_140 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial3", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_141, operands: STAGE6_FIELD_EXPR_OPERANDS_141 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial4", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_142, operands: STAGE6_FIELD_EXPR_OPERANDS_142 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial5", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_143, operands: STAGE6_FIELD_EXPR_OPERANDS_143 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial6", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_144, operands: STAGE6_FIELD_EXPR_OPERANDS_144 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial7", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_145, operands: STAGE6_FIELD_EXPR_OPERANDS_145 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial8", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_146, operands: STAGE6_FIELD_EXPR_OPERANDS_146 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial9", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_147, operands: STAGE6_FIELD_EXPR_OPERANDS_147 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial10", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_148, operands: STAGE6_FIELD_EXPR_OPERANDS_148 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial11", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_149, operands: STAGE6_FIELD_EXPR_OPERANDS_149 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial12", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_150, operands: STAGE6_FIELD_EXPR_OPERANDS_150 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial13", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_151, operands: STAGE6_FIELD_EXPR_OPERANDS_151 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial14", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_152, operands: STAGE6_FIELD_EXPR_OPERANDS_152 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial15", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_153, operands: STAGE6_FIELD_EXPR_OPERANDS_153 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial16", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_154, operands: STAGE6_FIELD_EXPR_OPERANDS_154 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial17", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_155, operands: STAGE6_FIELD_EXPR_OPERANDS_155 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial18", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_156, operands: STAGE6_FIELD_EXPR_OPERANDS_156 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial19", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_157, operands: STAGE6_FIELD_EXPR_OPERANDS_157 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial20", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_158, operands: STAGE6_FIELD_EXPR_OPERANDS_158 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial21", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_159, operands: STAGE6_FIELD_EXPR_OPERANDS_159 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial22", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_160, operands: STAGE6_FIELD_EXPR_OPERANDS_160 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial23", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_161, operands: STAGE6_FIELD_EXPR_OPERANDS_161 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial24", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_162, operands: STAGE6_FIELD_EXPR_OPERANDS_162 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial25", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_163, operands: STAGE6_FIELD_EXPR_OPERANDS_163 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial26", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_164, operands: STAGE6_FIELD_EXPR_OPERANDS_164 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial27", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_165, operands: STAGE6_FIELD_EXPR_OPERANDS_165 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial28", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_166, operands: STAGE6_FIELD_EXPR_OPERANDS_166 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial29", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_167, operands: STAGE6_FIELD_EXPR_OPERANDS_167 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial30", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_168, operands: STAGE6_FIELD_EXPR_OPERANDS_168 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial31", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_169, operands: STAGE6_FIELD_EXPR_OPERANDS_169 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial32", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_170, operands: STAGE6_FIELD_EXPR_OPERANDS_170 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial33", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_171, operands: STAGE6_FIELD_EXPR_OPERANDS_171 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial34", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_172, operands: STAGE6_FIELD_EXPR_OPERANDS_172 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial35", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_173, operands: STAGE6_FIELD_EXPR_OPERANDS_173 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial36", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_174, operands: STAGE6_FIELD_EXPR_OPERANDS_174 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial37", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_175, operands: STAGE6_FIELD_EXPR_OPERANDS_175 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial38", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_176, operands: STAGE6_FIELD_EXPR_OPERANDS_176 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial39", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_177, operands: STAGE6_FIELD_EXPR_OPERANDS_177 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial40", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_178, operands: STAGE6_FIELD_EXPR_OPERANDS_178 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial41", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_179, operands: STAGE6_FIELD_EXPR_OPERANDS_179 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial42", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_180, operands: STAGE6_FIELD_EXPR_OPERANDS_180 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial43", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_181, operands: STAGE6_FIELD_EXPR_OPERANDS_181 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial44", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_182, operands: STAGE6_FIELD_EXPR_OPERANDS_182 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial45", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_183, operands: STAGE6_FIELD_EXPR_OPERANDS_183 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial46", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_184, operands: STAGE6_FIELD_EXPR_OPERANDS_184 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial47", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_185, operands: STAGE6_FIELD_EXPR_OPERANDS_185 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial48", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_186, operands: STAGE6_FIELD_EXPR_OPERANDS_186 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial49", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_187, operands: STAGE6_FIELD_EXPR_OPERANDS_187 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial50", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_188, operands: STAGE6_FIELD_EXPR_OPERANDS_188 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial51", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_189, operands: STAGE6_FIELD_EXPR_OPERANDS_189 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial52", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_190, operands: STAGE6_FIELD_EXPR_OPERANDS_190 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial53", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_191, operands: STAGE6_FIELD_EXPR_OPERANDS_191 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial54", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_192, operands: STAGE6_FIELD_EXPR_OPERANDS_192 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial55", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_193, operands: STAGE6_FIELD_EXPR_OPERANDS_193 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial56", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_194, operands: STAGE6_FIELD_EXPR_OPERANDS_194 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial57", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_195, operands: STAGE6_FIELD_EXPR_OPERANDS_195 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial58", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_196, operands: STAGE6_FIELD_EXPR_OPERANDS_196 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial59", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_197, operands: STAGE6_FIELD_EXPR_OPERANDS_197 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial60", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_198, operands: STAGE6_FIELD_EXPR_OPERANDS_198 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial61", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_199, operands: STAGE6_FIELD_EXPR_OPERANDS_199 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial62", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_200, operands: STAGE6_FIELD_EXPR_OPERANDS_200 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial63", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_201, operands: STAGE6_FIELD_EXPR_OPERANDS_201 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial64", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_202, operands: STAGE6_FIELD_EXPR_OPERANDS_202 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial65", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_203, operands: STAGE6_FIELD_EXPR_OPERANDS_203 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial66", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_204, operands: STAGE6_FIELD_EXPR_OPERANDS_204 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial67", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_205, operands: STAGE6_FIELD_EXPR_OPERANDS_205 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial68", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_206, operands: STAGE6_FIELD_EXPR_OPERANDS_206 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial69", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_207, operands: STAGE6_FIELD_EXPR_OPERANDS_207 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial70", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_208, operands: STAGE6_FIELD_EXPR_OPERANDS_208 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial71", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_209, operands: STAGE6_FIELD_EXPR_OPERANDS_209 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial72", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_210, operands: STAGE6_FIELD_EXPR_OPERANDS_210 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial73", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_211, operands: STAGE6_FIELD_EXPR_OPERANDS_211 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial74", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_212, operands: STAGE6_FIELD_EXPR_OPERANDS_212 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial75", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_213, operands: STAGE6_FIELD_EXPR_OPERANDS_213 }, - Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial76", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term1.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term1.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_216, operands: STAGE6_FIELD_EXPR_OPERANDS_216 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term2.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term2.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_217, operands: STAGE6_FIELD_EXPR_OPERANDS_217 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term3.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term3.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_218, operands: STAGE6_FIELD_EXPR_OPERANDS_218 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term4.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_219, operands: STAGE6_FIELD_EXPR_OPERANDS_219 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term5.gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term5.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_220, operands: STAGE6_FIELD_EXPR_OPERANDS_220 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term6.gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term6.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_221, operands: STAGE6_FIELD_EXPR_OPERANDS_221 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term7.gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term7.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_222, operands: STAGE6_FIELD_EXPR_OPERANDS_222 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_223, operands: STAGE6_FIELD_EXPR_OPERANDS_223 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_224, operands: STAGE6_FIELD_EXPR_OPERANDS_224 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_225, operands: STAGE6_FIELD_EXPR_OPERANDS_225 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial3", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_226, operands: STAGE6_FIELD_EXPR_OPERANDS_226 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial4", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_227, operands: STAGE6_FIELD_EXPR_OPERANDS_227 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial5", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_228, operands: STAGE6_FIELD_EXPR_OPERANDS_228 }, - Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial6", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_229, operands: STAGE6_FIELD_EXPR_OPERANDS_229 }, - Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_230, operands: STAGE6_FIELD_EXPR_OPERANDS_230 }, - Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_231, operands: STAGE6_FIELD_EXPR_OPERANDS_231 }, - Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_230, operands: STAGE6_FIELD_EXPR_OPERANDS_230 }, - Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_232, operands: STAGE6_FIELD_EXPR_OPERANDS_232 }, - Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_230, operands: STAGE6_FIELD_EXPR_OPERANDS_230 }, - Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_233, operands: STAGE6_FIELD_EXPR_OPERANDS_233 }, - Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_234, operands: STAGE6_FIELD_EXPR_OPERANDS_234 }, - Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_235, operands: STAGE6_FIELD_EXPR_OPERANDS_235 }, - Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_236, operands: STAGE6_FIELD_EXPR_OPERANDS_236 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term1.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_1, operands: STAGE6_FIELD_EXPR_OPERANDS_1 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term2.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_2, operands: STAGE6_FIELD_EXPR_OPERANDS_2 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term3.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_3, operands: STAGE6_FIELD_EXPR_OPERANDS_3 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term4.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_4, operands: STAGE6_FIELD_EXPR_OPERANDS_4 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term5.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_5, operands: STAGE6_FIELD_EXPR_OPERANDS_5 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term6.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_6, operands: STAGE6_FIELD_EXPR_OPERANDS_6 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term7.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_7, operands: STAGE6_FIELD_EXPR_OPERANDS_7 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term8.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_8, operands: STAGE6_FIELD_EXPR_OPERANDS_8 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", kind: "op", formula: "field.pow:9", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term9.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_9, operands: STAGE6_FIELD_EXPR_OPERANDS_9 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term10.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_10, operands: STAGE6_FIELD_EXPR_OPERANDS_10 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", kind: "op", formula: "field.pow:11", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term11.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_11, operands: STAGE6_FIELD_EXPR_OPERANDS_11 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term12.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_12, operands: STAGE6_FIELD_EXPR_OPERANDS_12 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", kind: "op", formula: "field.pow:13", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term13.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_13, operands: STAGE6_FIELD_EXPR_OPERANDS_13 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term14.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_14, operands: STAGE6_FIELD_EXPR_OPERANDS_14 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", kind: "op", formula: "field.pow:15", operand_names: STAGE6_FIELD_EXPR_OPERANDS_0, operands: STAGE6_FIELD_EXPR_OPERANDS_0 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term15.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_15, operands: STAGE6_FIELD_EXPR_OPERANDS_15 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term16.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term16.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_17, operands: STAGE6_FIELD_EXPR_OPERANDS_17 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_18, operands: STAGE6_FIELD_EXPR_OPERANDS_18 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_19, operands: STAGE6_FIELD_EXPR_OPERANDS_19 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term17.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_20, operands: STAGE6_FIELD_EXPR_OPERANDS_20 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_18, operands: STAGE6_FIELD_EXPR_OPERANDS_18 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_21, operands: STAGE6_FIELD_EXPR_OPERANDS_21 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term18.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_22, operands: STAGE6_FIELD_EXPR_OPERANDS_22 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_18, operands: STAGE6_FIELD_EXPR_OPERANDS_18 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_23, operands: STAGE6_FIELD_EXPR_OPERANDS_23 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term19.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_24, operands: STAGE6_FIELD_EXPR_OPERANDS_24 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term20.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term20.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_25, operands: STAGE6_FIELD_EXPR_OPERANDS_25 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_27, operands: STAGE6_FIELD_EXPR_OPERANDS_27 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term21.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_28, operands: STAGE6_FIELD_EXPR_OPERANDS_28 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_29, operands: STAGE6_FIELD_EXPR_OPERANDS_29 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term22.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_30, operands: STAGE6_FIELD_EXPR_OPERANDS_30 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_31, operands: STAGE6_FIELD_EXPR_OPERANDS_31 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term23.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_32, operands: STAGE6_FIELD_EXPR_OPERANDS_32 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_33, operands: STAGE6_FIELD_EXPR_OPERANDS_33 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term24.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_34, operands: STAGE6_FIELD_EXPR_OPERANDS_34 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_35, operands: STAGE6_FIELD_EXPR_OPERANDS_35 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term25.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_36, operands: STAGE6_FIELD_EXPR_OPERANDS_36 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_37, operands: STAGE6_FIELD_EXPR_OPERANDS_37 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term26.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_38, operands: STAGE6_FIELD_EXPR_OPERANDS_38 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_39, operands: STAGE6_FIELD_EXPR_OPERANDS_39 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term27.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_40, operands: STAGE6_FIELD_EXPR_OPERANDS_40 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_26, operands: STAGE6_FIELD_EXPR_OPERANDS_26 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_41, operands: STAGE6_FIELD_EXPR_OPERANDS_41 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term28.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_42, operands: STAGE6_FIELD_EXPR_OPERANDS_42 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term29.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term29.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_43, operands: STAGE6_FIELD_EXPR_OPERANDS_43 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_44, operands: STAGE6_FIELD_EXPR_OPERANDS_44 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_45, operands: STAGE6_FIELD_EXPR_OPERANDS_45 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term30.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_46, operands: STAGE6_FIELD_EXPR_OPERANDS_46 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_44, operands: STAGE6_FIELD_EXPR_OPERANDS_44 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_47, operands: STAGE6_FIELD_EXPR_OPERANDS_47 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term31.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_48, operands: STAGE6_FIELD_EXPR_OPERANDS_48 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term32.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term32.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_49, operands: STAGE6_FIELD_EXPR_OPERANDS_49 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_51, operands: STAGE6_FIELD_EXPR_OPERANDS_51 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term33.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_52, operands: STAGE6_FIELD_EXPR_OPERANDS_52 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_53, operands: STAGE6_FIELD_EXPR_OPERANDS_53 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term34.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_54, operands: STAGE6_FIELD_EXPR_OPERANDS_54 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_55, operands: STAGE6_FIELD_EXPR_OPERANDS_55 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term35.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_56, operands: STAGE6_FIELD_EXPR_OPERANDS_56 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_57, operands: STAGE6_FIELD_EXPR_OPERANDS_57 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term36.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_58, operands: STAGE6_FIELD_EXPR_OPERANDS_58 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_59, operands: STAGE6_FIELD_EXPR_OPERANDS_59 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term37.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_60, operands: STAGE6_FIELD_EXPR_OPERANDS_60 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_61, operands: STAGE6_FIELD_EXPR_OPERANDS_61 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term38.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_62, operands: STAGE6_FIELD_EXPR_OPERANDS_62 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_63, operands: STAGE6_FIELD_EXPR_OPERANDS_63 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term39.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_64, operands: STAGE6_FIELD_EXPR_OPERANDS_64 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", kind: "op", formula: "field.pow:8", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_65, operands: STAGE6_FIELD_EXPR_OPERANDS_65 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term40.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_66, operands: STAGE6_FIELD_EXPR_OPERANDS_66 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", kind: "op", formula: "field.pow:9", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_67, operands: STAGE6_FIELD_EXPR_OPERANDS_67 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term41.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_68, operands: STAGE6_FIELD_EXPR_OPERANDS_68 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", kind: "op", formula: "field.pow:10", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_69, operands: STAGE6_FIELD_EXPR_OPERANDS_69 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term42.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_70, operands: STAGE6_FIELD_EXPR_OPERANDS_70 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", kind: "op", formula: "field.pow:11", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_71, operands: STAGE6_FIELD_EXPR_OPERANDS_71 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term43.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_72, operands: STAGE6_FIELD_EXPR_OPERANDS_72 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", kind: "op", formula: "field.pow:12", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_73, operands: STAGE6_FIELD_EXPR_OPERANDS_73 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term44.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_74, operands: STAGE6_FIELD_EXPR_OPERANDS_74 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", kind: "op", formula: "field.pow:13", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_75, operands: STAGE6_FIELD_EXPR_OPERANDS_75 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term45.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_76, operands: STAGE6_FIELD_EXPR_OPERANDS_76 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", kind: "op", formula: "field.pow:14", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_77, operands: STAGE6_FIELD_EXPR_OPERANDS_77 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term46.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_78, operands: STAGE6_FIELD_EXPR_OPERANDS_78 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", kind: "op", formula: "field.pow:15", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_79, operands: STAGE6_FIELD_EXPR_OPERANDS_79 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term47.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_80, operands: STAGE6_FIELD_EXPR_OPERANDS_80 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", kind: "op", formula: "field.pow:16", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_81, operands: STAGE6_FIELD_EXPR_OPERANDS_81 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term48.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_82, operands: STAGE6_FIELD_EXPR_OPERANDS_82 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", kind: "op", formula: "field.pow:17", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_83, operands: STAGE6_FIELD_EXPR_OPERANDS_83 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term49.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_84, operands: STAGE6_FIELD_EXPR_OPERANDS_84 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", kind: "op", formula: "field.pow:18", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_85, operands: STAGE6_FIELD_EXPR_OPERANDS_85 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term50.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_86, operands: STAGE6_FIELD_EXPR_OPERANDS_86 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", kind: "op", formula: "field.pow:19", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_87, operands: STAGE6_FIELD_EXPR_OPERANDS_87 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term51.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_88, operands: STAGE6_FIELD_EXPR_OPERANDS_88 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", kind: "op", formula: "field.pow:20", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_89, operands: STAGE6_FIELD_EXPR_OPERANDS_89 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term52.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_90, operands: STAGE6_FIELD_EXPR_OPERANDS_90 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", kind: "op", formula: "field.pow:21", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_91, operands: STAGE6_FIELD_EXPR_OPERANDS_91 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term53.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_92, operands: STAGE6_FIELD_EXPR_OPERANDS_92 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", kind: "op", formula: "field.pow:22", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_93, operands: STAGE6_FIELD_EXPR_OPERANDS_93 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term54.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_94, operands: STAGE6_FIELD_EXPR_OPERANDS_94 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", kind: "op", formula: "field.pow:23", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_95, operands: STAGE6_FIELD_EXPR_OPERANDS_95 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term55.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_96, operands: STAGE6_FIELD_EXPR_OPERANDS_96 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", kind: "op", formula: "field.pow:24", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_97, operands: STAGE6_FIELD_EXPR_OPERANDS_97 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term56.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_98, operands: STAGE6_FIELD_EXPR_OPERANDS_98 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", kind: "op", formula: "field.pow:25", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_99, operands: STAGE6_FIELD_EXPR_OPERANDS_99 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term57.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_100, operands: STAGE6_FIELD_EXPR_OPERANDS_100 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", kind: "op", formula: "field.pow:26", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_101, operands: STAGE6_FIELD_EXPR_OPERANDS_101 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term58.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_102, operands: STAGE6_FIELD_EXPR_OPERANDS_102 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", kind: "op", formula: "field.pow:27", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_103, operands: STAGE6_FIELD_EXPR_OPERANDS_103 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term59.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_104, operands: STAGE6_FIELD_EXPR_OPERANDS_104 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", kind: "op", formula: "field.pow:28", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_105, operands: STAGE6_FIELD_EXPR_OPERANDS_105 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term60.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_106, operands: STAGE6_FIELD_EXPR_OPERANDS_106 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", kind: "op", formula: "field.pow:29", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_107, operands: STAGE6_FIELD_EXPR_OPERANDS_107 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term61.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_108, operands: STAGE6_FIELD_EXPR_OPERANDS_108 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", kind: "op", formula: "field.pow:30", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_109, operands: STAGE6_FIELD_EXPR_OPERANDS_109 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term62.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_110, operands: STAGE6_FIELD_EXPR_OPERANDS_110 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", kind: "op", formula: "field.pow:31", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_111, operands: STAGE6_FIELD_EXPR_OPERANDS_111 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term63.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_112, operands: STAGE6_FIELD_EXPR_OPERANDS_112 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", kind: "op", formula: "field.pow:32", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_113, operands: STAGE6_FIELD_EXPR_OPERANDS_113 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term64.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_114, operands: STAGE6_FIELD_EXPR_OPERANDS_114 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", kind: "op", formula: "field.pow:33", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_115, operands: STAGE6_FIELD_EXPR_OPERANDS_115 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term65.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_116, operands: STAGE6_FIELD_EXPR_OPERANDS_116 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", kind: "op", formula: "field.pow:34", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_117, operands: STAGE6_FIELD_EXPR_OPERANDS_117 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term66.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_118, operands: STAGE6_FIELD_EXPR_OPERANDS_118 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", kind: "op", formula: "field.pow:35", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_119, operands: STAGE6_FIELD_EXPR_OPERANDS_119 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term67.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_120, operands: STAGE6_FIELD_EXPR_OPERANDS_120 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", kind: "op", formula: "field.pow:36", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_121, operands: STAGE6_FIELD_EXPR_OPERANDS_121 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term68.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_122, operands: STAGE6_FIELD_EXPR_OPERANDS_122 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", kind: "op", formula: "field.pow:37", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_123, operands: STAGE6_FIELD_EXPR_OPERANDS_123 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term69.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_124, operands: STAGE6_FIELD_EXPR_OPERANDS_124 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", kind: "op", formula: "field.pow:38", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_125, operands: STAGE6_FIELD_EXPR_OPERANDS_125 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term70.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_126, operands: STAGE6_FIELD_EXPR_OPERANDS_126 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", kind: "op", formula: "field.pow:39", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_127, operands: STAGE6_FIELD_EXPR_OPERANDS_127 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term71.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_128, operands: STAGE6_FIELD_EXPR_OPERANDS_128 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", kind: "op", formula: "field.pow:40", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_129, operands: STAGE6_FIELD_EXPR_OPERANDS_129 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term72.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_130, operands: STAGE6_FIELD_EXPR_OPERANDS_130 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", kind: "op", formula: "field.pow:41", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_131, operands: STAGE6_FIELD_EXPR_OPERANDS_131 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term73.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_132, operands: STAGE6_FIELD_EXPR_OPERANDS_132 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", kind: "op", formula: "field.pow:42", operand_names: STAGE6_FIELD_EXPR_OPERANDS_50, operands: STAGE6_FIELD_EXPR_OPERANDS_50 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.stage_gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_133, operands: STAGE6_FIELD_EXPR_OPERANDS_133 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term74.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_134, operands: STAGE6_FIELD_EXPR_OPERANDS_134 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term75.gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term75.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_135, operands: STAGE6_FIELD_EXPR_OPERANDS_135 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term76.gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.term76.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_136, operands: STAGE6_FIELD_EXPR_OPERANDS_136 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim.entry_constant", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_16, operands: STAGE6_FIELD_EXPR_OPERANDS_16 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_137, operands: STAGE6_FIELD_EXPR_OPERANDS_137 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_138, operands: STAGE6_FIELD_EXPR_OPERANDS_138 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_139, operands: STAGE6_FIELD_EXPR_OPERANDS_139 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial3", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_140, operands: STAGE6_FIELD_EXPR_OPERANDS_140 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial4", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_141, operands: STAGE6_FIELD_EXPR_OPERANDS_141 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial5", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_142, operands: STAGE6_FIELD_EXPR_OPERANDS_142 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial6", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_143, operands: STAGE6_FIELD_EXPR_OPERANDS_143 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial7", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_144, operands: STAGE6_FIELD_EXPR_OPERANDS_144 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial8", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_145, operands: STAGE6_FIELD_EXPR_OPERANDS_145 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial9", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_146, operands: STAGE6_FIELD_EXPR_OPERANDS_146 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial10", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_147, operands: STAGE6_FIELD_EXPR_OPERANDS_147 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial11", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_148, operands: STAGE6_FIELD_EXPR_OPERANDS_148 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial12", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_149, operands: STAGE6_FIELD_EXPR_OPERANDS_149 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial13", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_150, operands: STAGE6_FIELD_EXPR_OPERANDS_150 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial14", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_151, operands: STAGE6_FIELD_EXPR_OPERANDS_151 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial15", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_152, operands: STAGE6_FIELD_EXPR_OPERANDS_152 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial16", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_153, operands: STAGE6_FIELD_EXPR_OPERANDS_153 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial17", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_154, operands: STAGE6_FIELD_EXPR_OPERANDS_154 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial18", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_155, operands: STAGE6_FIELD_EXPR_OPERANDS_155 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial19", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_156, operands: STAGE6_FIELD_EXPR_OPERANDS_156 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial20", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_157, operands: STAGE6_FIELD_EXPR_OPERANDS_157 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial21", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_158, operands: STAGE6_FIELD_EXPR_OPERANDS_158 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial22", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_159, operands: STAGE6_FIELD_EXPR_OPERANDS_159 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial23", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_160, operands: STAGE6_FIELD_EXPR_OPERANDS_160 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial24", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_161, operands: STAGE6_FIELD_EXPR_OPERANDS_161 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial25", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_162, operands: STAGE6_FIELD_EXPR_OPERANDS_162 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial26", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_163, operands: STAGE6_FIELD_EXPR_OPERANDS_163 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial27", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_164, operands: STAGE6_FIELD_EXPR_OPERANDS_164 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial28", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_165, operands: STAGE6_FIELD_EXPR_OPERANDS_165 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial29", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_166, operands: STAGE6_FIELD_EXPR_OPERANDS_166 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial30", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_167, operands: STAGE6_FIELD_EXPR_OPERANDS_167 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial31", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_168, operands: STAGE6_FIELD_EXPR_OPERANDS_168 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial32", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_169, operands: STAGE6_FIELD_EXPR_OPERANDS_169 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial33", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_170, operands: STAGE6_FIELD_EXPR_OPERANDS_170 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial34", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_171, operands: STAGE6_FIELD_EXPR_OPERANDS_171 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial35", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_172, operands: STAGE6_FIELD_EXPR_OPERANDS_172 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial36", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_173, operands: STAGE6_FIELD_EXPR_OPERANDS_173 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial37", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_174, operands: STAGE6_FIELD_EXPR_OPERANDS_174 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial38", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_175, operands: STAGE6_FIELD_EXPR_OPERANDS_175 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial39", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_176, operands: STAGE6_FIELD_EXPR_OPERANDS_176 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial40", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_177, operands: STAGE6_FIELD_EXPR_OPERANDS_177 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial41", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_178, operands: STAGE6_FIELD_EXPR_OPERANDS_178 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial42", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_179, operands: STAGE6_FIELD_EXPR_OPERANDS_179 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial43", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_180, operands: STAGE6_FIELD_EXPR_OPERANDS_180 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial44", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_181, operands: STAGE6_FIELD_EXPR_OPERANDS_181 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial45", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_182, operands: STAGE6_FIELD_EXPR_OPERANDS_182 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial46", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_183, operands: STAGE6_FIELD_EXPR_OPERANDS_183 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial47", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_184, operands: STAGE6_FIELD_EXPR_OPERANDS_184 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial48", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_185, operands: STAGE6_FIELD_EXPR_OPERANDS_185 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial49", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_186, operands: STAGE6_FIELD_EXPR_OPERANDS_186 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial50", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_187, operands: STAGE6_FIELD_EXPR_OPERANDS_187 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial51", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_188, operands: STAGE6_FIELD_EXPR_OPERANDS_188 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial52", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_189, operands: STAGE6_FIELD_EXPR_OPERANDS_189 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial53", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_190, operands: STAGE6_FIELD_EXPR_OPERANDS_190 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial54", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_191, operands: STAGE6_FIELD_EXPR_OPERANDS_191 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial55", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_192, operands: STAGE6_FIELD_EXPR_OPERANDS_192 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial56", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_193, operands: STAGE6_FIELD_EXPR_OPERANDS_193 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial57", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_194, operands: STAGE6_FIELD_EXPR_OPERANDS_194 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial58", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_195, operands: STAGE6_FIELD_EXPR_OPERANDS_195 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial59", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_196, operands: STAGE6_FIELD_EXPR_OPERANDS_196 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial60", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_197, operands: STAGE6_FIELD_EXPR_OPERANDS_197 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial61", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_198, operands: STAGE6_FIELD_EXPR_OPERANDS_198 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial62", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_199, operands: STAGE6_FIELD_EXPR_OPERANDS_199 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial63", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_200, operands: STAGE6_FIELD_EXPR_OPERANDS_200 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial64", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_201, operands: STAGE6_FIELD_EXPR_OPERANDS_201 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial65", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_202, operands: STAGE6_FIELD_EXPR_OPERANDS_202 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial66", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_203, operands: STAGE6_FIELD_EXPR_OPERANDS_203 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial67", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_204, operands: STAGE6_FIELD_EXPR_OPERANDS_204 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial68", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_205, operands: STAGE6_FIELD_EXPR_OPERANDS_205 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial69", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_206, operands: STAGE6_FIELD_EXPR_OPERANDS_206 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial70", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_207, operands: STAGE6_FIELD_EXPR_OPERANDS_207 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial71", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_208, operands: STAGE6_FIELD_EXPR_OPERANDS_208 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial72", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_209, operands: STAGE6_FIELD_EXPR_OPERANDS_209 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial73", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_210, operands: STAGE6_FIELD_EXPR_OPERANDS_210 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial74", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_211, operands: STAGE6_FIELD_EXPR_OPERANDS_211 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial75", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_212, operands: STAGE6_FIELD_EXPR_OPERANDS_212 }, + Stage6FieldExprPlan { symbol: "stage6.bytecode_read_raf.claim_expr.partial76", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_213, operands: STAGE6_FIELD_EXPR_OPERANDS_213 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term1.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term1.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_215, operands: STAGE6_FIELD_EXPR_OPERANDS_215 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term2.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term2.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_216, operands: STAGE6_FIELD_EXPR_OPERANDS_216 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term3.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term3.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_217, operands: STAGE6_FIELD_EXPR_OPERANDS_217 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term4.gamma_pow", kind: "op", formula: "field.pow:4", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_218, operands: STAGE6_FIELD_EXPR_OPERANDS_218 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term5.gamma_pow", kind: "op", formula: "field.pow:5", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term5.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_219, operands: STAGE6_FIELD_EXPR_OPERANDS_219 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term6.gamma_pow", kind: "op", formula: "field.pow:6", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term6.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_220, operands: STAGE6_FIELD_EXPR_OPERANDS_220 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term7.gamma_pow", kind: "op", formula: "field.pow:7", operand_names: STAGE6_FIELD_EXPR_OPERANDS_214, operands: STAGE6_FIELD_EXPR_OPERANDS_214 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim.term7.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_221, operands: STAGE6_FIELD_EXPR_OPERANDS_221 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_222, operands: STAGE6_FIELD_EXPR_OPERANDS_222 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_223, operands: STAGE6_FIELD_EXPR_OPERANDS_223 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_224, operands: STAGE6_FIELD_EXPR_OPERANDS_224 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial3", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_225, operands: STAGE6_FIELD_EXPR_OPERANDS_225 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial4", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_226, operands: STAGE6_FIELD_EXPR_OPERANDS_226 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial5", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_227, operands: STAGE6_FIELD_EXPR_OPERANDS_227 }, + Stage6FieldExprPlan { symbol: "stage6.instruction_ra_virtual.claim_expr.partial6", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_228, operands: STAGE6_FIELD_EXPR_OPERANDS_228 }, + Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", kind: "op", formula: "field.pow:1", operand_names: STAGE6_FIELD_EXPR_OPERANDS_229, operands: STAGE6_FIELD_EXPR_OPERANDS_229 }, + Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_230, operands: STAGE6_FIELD_EXPR_OPERANDS_230 }, + Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", kind: "op", formula: "field.pow:2", operand_names: STAGE6_FIELD_EXPR_OPERANDS_229, operands: STAGE6_FIELD_EXPR_OPERANDS_229 }, + Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_231, operands: STAGE6_FIELD_EXPR_OPERANDS_231 }, + Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", kind: "op", formula: "field.pow:3", operand_names: STAGE6_FIELD_EXPR_OPERANDS_229, operands: STAGE6_FIELD_EXPR_OPERANDS_229 }, + Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", kind: "op", formula: "field.mul", operand_names: STAGE6_FIELD_EXPR_OPERANDS_232, operands: STAGE6_FIELD_EXPR_OPERANDS_232 }, + Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial0", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_233, operands: STAGE6_FIELD_EXPR_OPERANDS_233 }, + Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial1", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_234, operands: STAGE6_FIELD_EXPR_OPERANDS_234 }, + Stage6FieldExprPlan { symbol: "stage6.inc_claim_reduction.claim_expr.partial2", kind: "op", formula: "field.add", operand_names: STAGE6_FIELD_EXPR_OPERANDS_235, operands: STAGE6_FIELD_EXPR_OPERANDS_235 }, ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ Stage6KernelPlan { symbol: "jolt.cpu.stage6.bytecode_read_raf", relation: "jolt.stage6.bytecode_read_raf", kind: "sumcheck", backend: "cpu", abi: "jolt_stage6_bytecode_read_raf" }, @@ -1975,6 +1895,8 @@ pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[ Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, + Stage6PointSlicePlan { symbol: "stage6.booleanity.output.point.Address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" }, + Stage6PointSlicePlan { symbol: "stage6.booleanity.output.point.Cycle", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 16, length: 16, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" }, ]; pub const STAGE6_POINT_CONCAT_0_INPUTS: &[&str] = &[ @@ -2177,6 +2099,11 @@ pub const STAGE6_POINT_CONCAT_39_INPUTS: &[&str] = &[ "stage6.instruction_ra_virtual.instance", ]; +pub const STAGE6_POINT_CONCAT_40_INPUTS: &[&str] = &[ + "stage6.booleanity.output.point.Address", + "stage6.booleanity.output.point.Cycle", +]; + pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[ Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address", layout: "left_zero_padded_address_chunk", arity: 4, inputs: STAGE6_POINT_CONCAT_0_INPUTS }, Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: STAGE6_POINT_CONCAT_1_INPUTS }, @@ -2218,6 +2145,7 @@ pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[ Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29", layout: "address_chunk_then_cycle", arity: 20, inputs: STAGE6_POINT_CONCAT_37_INPUTS }, Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30", layout: "address_chunk_then_cycle", arity: 20, inputs: STAGE6_POINT_CONCAT_38_INPUTS }, Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31", layout: "address_chunk_then_cycle", arity: 20, inputs: STAGE6_POINT_CONCAT_39_INPUTS }, + Stage6PointConcatPlan { symbol: "stage6.booleanity.output.point", layout: "address_prefix_then_cycle", arity: 20, inputs: STAGE6_POINT_CONCAT_40_INPUTS }, ]; pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[ Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: "committed", point_source: "stage6.bytecode_read_raf.point.BytecodeRa_0", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_0" }, diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 1b3c5cb4a5..3a7784cc1d 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -12,8 +12,8 @@ //! - point normalizations for the Jolt bytecode and instruction RA //! read-RAF lookup arguments //! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement -//! - the remaining `expected_stage67_*` relation evaluators for Stage 6 -//! booleanity and bytecode-read-RAF relations +//! - the remaining `expected_stage67_*` relation evaluator for the Stage 6 +//! bytecode-read-RAF relation //! - the small Jolt-specific field-math helpers //! (`operand_polynomial_eval`, `identity_polynomial_eval`, //! `lt_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt @@ -26,7 +26,7 @@ //! //! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition. -use jolt_field::{Field, Fr, MulPow2, RingCore}; +use jolt_field::{Field, Fr, MulPow2}; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ @@ -86,13 +86,6 @@ pub fn normalize_instruction_read_raf_point( #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage67RelationSymbols { pub hamming_booleanity_instance: &'static str, - pub booleanity_point: &'static str, - pub stage5_instruction_ra0: &'static str, - pub booleanity_combined_point: &'static str, - pub booleanity_gamma: &'static str, - pub booleanity_instruction_ra_prefix: &'static str, - pub booleanity_bytecode_ra_prefix: &'static str, - pub booleanity_ram_ra_prefix: &'static str, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -198,83 +191,6 @@ pub fn expected_stage67_bytecode_read_raf( Ok((val + entry_contrib) * bytecode_ra) } -pub fn expected_stage67_booleanity( - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], - log_t: usize, - symbols: &Stage67RelationSymbols, -) -> Result { - let log_k_chunk = - local_point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.booleanity_point, - expected: log_t, - actual: local_point.len(), - })?; - let stage5_point = store_point(store, symbols.stage5_instruction_ra0)?; - let stage5_address_len = - stage5_point - .len() - .checked_sub(log_t) - .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.stage5_instruction_ra0, - expected: log_t, - actual: stage5_point.len(), - })?; - if stage5_address_len < log_k_chunk { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.stage5_instruction_ra0, - expected: log_k_chunk + log_t, - actual: stage5_point.len(), - }); - } - - let mut stage5_addr = stage5_point[..stage5_address_len].to_vec(); - stage5_addr.reverse(); - let mut combined_r = stage5_addr[stage5_address_len - log_k_chunk..].to_vec(); - combined_r.extend(stage5_point[stage5_address_len..].iter().rev().copied()); - if combined_r.len() != local_point.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.booleanity_combined_point, - expected: local_point.len(), - actual: combined_r.len(), - }); - } - let mut verifier_point = combined_r[..log_k_chunk].to_vec(); - verifier_point.reverse(); - verifier_point.extend(combined_r[log_k_chunk..].iter().rev().copied()); - let eq_eval = EqPolynomial::::mle(local_point, &verifier_point); - - let gamma = store_scalar(store, symbols.booleanity_gamma)?; - let gamma_sq = gamma.square(); - let mut gamma_power = Fr::from_u64(1); - let mut booleanity = Fr::from_u64(0); - for ra in stage67_booleanity_evals(evals, symbols)? { - booleanity += gamma_power * (ra.square() - ra); - gamma_power *= gamma_sq; - } - Ok(eq_eval * booleanity) -} - -fn stage67_booleanity_evals( - evals: &[StageNamedEval], - symbols: &Stage67RelationSymbols, -) -> Result, RuntimePlanError> { - let mut values = indexed_evals_by_prefix_any(evals, symbols.booleanity_instruction_ra_prefix)?; - values.extend(indexed_evals_by_prefix_any( - evals, - symbols.booleanity_bytecode_ra_prefix, - )?); - values.extend(indexed_evals_by_prefix_any( - evals, - symbols.booleanity_ram_ra_prefix, - )?); - Ok(values) -} - fn stage67_bytecode_stage_cycle_points( store: &ValueStore, log_t: usize, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 8ab1faac17..b00fb0c4a0 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; -use super::jolt_relations::{expected_stage67_booleanity, expected_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols}; +use super::jolt_relations::{expected_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -97,13 +97,6 @@ pub struct Stage6VerifierData { const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { hamming_booleanity_instance: "stage6.hamming_booleanity.instance", - booleanity_point: "stage6.booleanity.point", - stage5_instruction_ra0: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", - booleanity_combined_point: "stage6.booleanity.combined_point", - booleanity_gamma: "stage6.booleanity.gamma", - booleanity_instruction_ra_prefix: "stage6.booleanity.eval.InstructionRa_", - booleanity_bytecode_ra_prefix: "stage6.booleanity.eval.BytecodeRa_", - booleanity_ram_ra_prefix: "stage6.booleanity.eval.RamRa_", }; const STAGE6_BYTECODE_SYMBOLS: Stage67BytecodeSymbols = Stage67BytecodeSymbols { @@ -283,62 +276,53 @@ const fn stage6_field_expr(symbol: &'static str, kind: Stage6FieldExprKind, oper #[rustfmt::skip] pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ - stage6_field_expr("stage6.booleanity.gamma_sq_0", Stage6FieldExprKind::Pow(0), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_1", Stage6FieldExprKind::Pow(2), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_2", Stage6FieldExprKind::Pow(4), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_3", Stage6FieldExprKind::Pow(6), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_4", Stage6FieldExprKind::Pow(8), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_5", Stage6FieldExprKind::Pow(10), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_6", Stage6FieldExprKind::Pow(12), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_7", Stage6FieldExprKind::Pow(14), &["stage6.booleanity.gamma"]), - stage6_field_expr("stage6.booleanity.gamma_sq_8", Stage6FieldExprKind::Pow(16), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_9", Stage6FieldExprKind::Pow(18), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_10", Stage6FieldExprKind::Pow(20), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_11", Stage6FieldExprKind::Pow(22), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_12", Stage6FieldExprKind::Pow(24), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_13", Stage6FieldExprKind::Pow(26), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_14", Stage6FieldExprKind::Pow(28), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_15", Stage6FieldExprKind::Pow(30), &["stage6.booleanity.gamma"]), - stage6_field_expr("stage6.booleanity.gamma_sq_16", Stage6FieldExprKind::Pow(32), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_17", Stage6FieldExprKind::Pow(34), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_18", Stage6FieldExprKind::Pow(36), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_19", Stage6FieldExprKind::Pow(38), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_20", Stage6FieldExprKind::Pow(40), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_21", Stage6FieldExprKind::Pow(42), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_22", Stage6FieldExprKind::Pow(44), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_23", Stage6FieldExprKind::Pow(46), &["stage6.booleanity.gamma"]), - stage6_field_expr("stage6.booleanity.gamma_sq_24", Stage6FieldExprKind::Pow(48), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_25", Stage6FieldExprKind::Pow(50), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_26", Stage6FieldExprKind::Pow(52), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_27", Stage6FieldExprKind::Pow(54), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_28", Stage6FieldExprKind::Pow(56), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_29", Stage6FieldExprKind::Pow(58), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_30", Stage6FieldExprKind::Pow(60), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_31", Stage6FieldExprKind::Pow(62), &["stage6.booleanity.gamma"]), - stage6_field_expr("stage6.booleanity.gamma_sq_32", Stage6FieldExprKind::Pow(64), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_33", Stage6FieldExprKind::Pow(66), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_34", Stage6FieldExprKind::Pow(68), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_35", Stage6FieldExprKind::Pow(70), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_36", Stage6FieldExprKind::Pow(72), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_37", Stage6FieldExprKind::Pow(74), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_sq_38", Stage6FieldExprKind::Pow(76), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_0", Stage6FieldExprKind::Pow(0), &["stage6.booleanity.gamma"]), - stage6_field_expr("stage6.booleanity.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_8", Stage6FieldExprKind::Pow(8), &["stage6.booleanity.gamma"]), - stage6_field_expr("stage6.booleanity.gamma_pow_9", Stage6FieldExprKind::Pow(9), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_10", Stage6FieldExprKind::Pow(10), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_11", Stage6FieldExprKind::Pow(11), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_12", Stage6FieldExprKind::Pow(12), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_13", Stage6FieldExprKind::Pow(13), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_14", Stage6FieldExprKind::Pow(14), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_15", Stage6FieldExprKind::Pow(15), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_16", Stage6FieldExprKind::Pow(16), &["stage6.booleanity.gamma"]), - stage6_field_expr("stage6.booleanity.gamma_pow_17", Stage6FieldExprKind::Pow(17), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_18", Stage6FieldExprKind::Pow(18), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_19", Stage6FieldExprKind::Pow(19), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_20", Stage6FieldExprKind::Pow(20), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_21", Stage6FieldExprKind::Pow(21), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_22", Stage6FieldExprKind::Pow(22), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_23", Stage6FieldExprKind::Pow(23), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_24", Stage6FieldExprKind::Pow(24), &["stage6.booleanity.gamma"]), - stage6_field_expr("stage6.booleanity.gamma_pow_25", Stage6FieldExprKind::Pow(25), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_26", Stage6FieldExprKind::Pow(26), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_27", Stage6FieldExprKind::Pow(27), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_28", Stage6FieldExprKind::Pow(28), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_29", Stage6FieldExprKind::Pow(29), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_30", Stage6FieldExprKind::Pow(30), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_31", Stage6FieldExprKind::Pow(31), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_32", Stage6FieldExprKind::Pow(32), &["stage6.booleanity.gamma"]), - stage6_field_expr("stage6.booleanity.gamma_pow_33", Stage6FieldExprKind::Pow(33), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_34", Stage6FieldExprKind::Pow(34), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_35", Stage6FieldExprKind::Pow(35), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_36", Stage6FieldExprKind::Pow(36), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_37", Stage6FieldExprKind::Pow(37), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.gamma_pow_38", Stage6FieldExprKind::Pow(38), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term1.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", "stage6.input.stage1.Imm"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term2.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", "stage6.input.stage1.OpFlagAddOperands"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term3.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", "stage6.input.stage1.OpFlagSubtractOperands"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term4.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", "stage6.input.stage1.OpFlagMultiplyOperands"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term5.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", "stage6.input.stage1.OpFlagLoad"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term6.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", "stage6.input.stage1.OpFlagStore"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term7.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", "stage6.input.stage1.OpFlagJump"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term8.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", "stage6.input.stage1.OpFlagWriteLookupOutputToRD"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term9.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", "stage6.input.stage1.OpFlagVirtualInstruction"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term10.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", "stage6.input.stage1.OpFlagAssert"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term11.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term12.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", "stage6.input.stage1.OpFlagAdvice"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term13.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", "stage6.input.stage1.OpFlagIsCompressed"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term14.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", "stage6.input.stage1.OpFlagIsFirstInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term15.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", "stage6.input.stage1.OpFlagIsLastInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term16.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term16.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term16.gamma_pow", "stage6.input.stage2.OpFlagJump"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", "stage6.input.stage2.InstructionFlagBranch"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term17.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.gamma_pow", "stage6.bytecode_read_raf.claim.term17.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", "stage6.input.stage2.OpFlagWriteLookupOutputToRD"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.gamma_pow", "stage6.bytecode_read_raf.claim.term18.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", "stage6.input.stage2.OpFlagVirtualInstruction"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term19.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.gamma_pow", "stage6.bytecode_read_raf.claim.term19.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term20.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term20.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term20.gamma_pow", "stage6.input.stage3.instruction_input.Imm"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", "stage6.input.stage3.spartan_shift.UnexpandedPC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.gamma_pow", "stage6.bytecode_read_raf.claim.term21.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.gamma_pow", "stage6.bytecode_read_raf.claim.term22.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.gamma_pow", "stage6.bytecode_read_raf.claim.term23.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.gamma_pow", "stage6.bytecode_read_raf.claim.term24.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.gamma_pow", "stage6.bytecode_read_raf.claim.term25.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.gamma_pow", "stage6.bytecode_read_raf.claim.term26.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.gamma_pow", "stage6.bytecode_read_raf.claim.term27.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.gamma_pow", "stage6.bytecode_read_raf.claim.term28.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term29.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term29.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term29.gamma_pow", "stage6.input.stage4.RdWa"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", "stage6.input.stage4.Rs1Ra"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term30.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.gamma_pow", "stage6.bytecode_read_raf.claim.term30.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", "stage6.input.stage4.Rs2Ra"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.gamma_pow", "stage6.bytecode_read_raf.claim.term31.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term32.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term32.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term32.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdWa"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", "stage6.input.stage5.InstructionRafFlag"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.gamma_pow", "stage6.bytecode_read_raf.claim.term33.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_0"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.gamma_pow", "stage6.bytecode_read_raf.claim.term34.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_1"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.gamma_pow", "stage6.bytecode_read_raf.claim.term35.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_2"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.gamma_pow", "stage6.bytecode_read_raf.claim.term36.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_3"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.gamma_pow", "stage6.bytecode_read_raf.claim.term37.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_4"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.gamma_pow", "stage6.bytecode_read_raf.claim.term38.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_5"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.gamma_pow", "stage6.bytecode_read_raf.claim.term39.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_6"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.gamma_pow", "stage6.bytecode_read_raf.claim.term40.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_7"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.gamma_pow", "stage6.bytecode_read_raf.claim.term41.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_8"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.gamma_pow", "stage6.bytecode_read_raf.claim.term42.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_9"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.gamma_pow", "stage6.bytecode_read_raf.claim.term43.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_10"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.gamma_pow", "stage6.bytecode_read_raf.claim.term44.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_11"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.gamma_pow", "stage6.bytecode_read_raf.claim.term45.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_12"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.gamma_pow", "stage6.bytecode_read_raf.claim.term46.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_13"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.gamma_pow", "stage6.bytecode_read_raf.claim.term47.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", Stage6FieldExprKind::Pow(16), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_14"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.gamma_pow", "stage6.bytecode_read_raf.claim.term48.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", Stage6FieldExprKind::Pow(17), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_15"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.gamma_pow", "stage6.bytecode_read_raf.claim.term49.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", Stage6FieldExprKind::Pow(18), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_16"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.gamma_pow", "stage6.bytecode_read_raf.claim.term50.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", Stage6FieldExprKind::Pow(19), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_17"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.gamma_pow", "stage6.bytecode_read_raf.claim.term51.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", Stage6FieldExprKind::Pow(20), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_18"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.gamma_pow", "stage6.bytecode_read_raf.claim.term52.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", Stage6FieldExprKind::Pow(21), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_19"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.gamma_pow", "stage6.bytecode_read_raf.claim.term53.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", Stage6FieldExprKind::Pow(22), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_20"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.gamma_pow", "stage6.bytecode_read_raf.claim.term54.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", Stage6FieldExprKind::Pow(23), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_21"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.gamma_pow", "stage6.bytecode_read_raf.claim.term55.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", Stage6FieldExprKind::Pow(24), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_22"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.gamma_pow", "stage6.bytecode_read_raf.claim.term56.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", Stage6FieldExprKind::Pow(25), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_23"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.gamma_pow", "stage6.bytecode_read_raf.claim.term57.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", Stage6FieldExprKind::Pow(26), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_24"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.gamma_pow", "stage6.bytecode_read_raf.claim.term58.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", Stage6FieldExprKind::Pow(27), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_25"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.gamma_pow", "stage6.bytecode_read_raf.claim.term59.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", Stage6FieldExprKind::Pow(28), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_26"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.gamma_pow", "stage6.bytecode_read_raf.claim.term60.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", Stage6FieldExprKind::Pow(29), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_27"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.gamma_pow", "stage6.bytecode_read_raf.claim.term61.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", Stage6FieldExprKind::Pow(30), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_28"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.gamma_pow", "stage6.bytecode_read_raf.claim.term62.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", Stage6FieldExprKind::Pow(31), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_29"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.gamma_pow", "stage6.bytecode_read_raf.claim.term63.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", Stage6FieldExprKind::Pow(32), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_30"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.gamma_pow", "stage6.bytecode_read_raf.claim.term64.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", Stage6FieldExprKind::Pow(33), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_31"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.gamma_pow", "stage6.bytecode_read_raf.claim.term65.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", Stage6FieldExprKind::Pow(34), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_32"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.gamma_pow", "stage6.bytecode_read_raf.claim.term66.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", Stage6FieldExprKind::Pow(35), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_33"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.gamma_pow", "stage6.bytecode_read_raf.claim.term67.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", Stage6FieldExprKind::Pow(36), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_34"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.gamma_pow", "stage6.bytecode_read_raf.claim.term68.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", Stage6FieldExprKind::Pow(37), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_35"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.gamma_pow", "stage6.bytecode_read_raf.claim.term69.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", Stage6FieldExprKind::Pow(38), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_36"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.gamma_pow", "stage6.bytecode_read_raf.claim.term70.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", Stage6FieldExprKind::Pow(39), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_37"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.gamma_pow", "stage6.bytecode_read_raf.claim.term71.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", Stage6FieldExprKind::Pow(40), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_38"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.gamma_pow", "stage6.bytecode_read_raf.claim.term72.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", Stage6FieldExprKind::Pow(41), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_39"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.gamma_pow", "stage6.bytecode_read_raf.claim.term73.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", Stage6FieldExprKind::Pow(42), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_40"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.gamma_pow", "stage6.bytecode_read_raf.claim.term74.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim.term75.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term75.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term75.gamma_pow", "stage6.input.stage1.PC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term76.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term76.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term76.gamma_pow", "stage6.input.stage3.spartan_shift.PC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.entry_constant", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage1.UnexpandedPC", "stage6.bytecode_read_raf.claim.term1.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial0", "stage6.bytecode_read_raf.claim.term2.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial1", "stage6.bytecode_read_raf.claim.term3.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial2", "stage6.bytecode_read_raf.claim.term4.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial3", "stage6.bytecode_read_raf.claim.term5.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial4", "stage6.bytecode_read_raf.claim.term6.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial5", "stage6.bytecode_read_raf.claim.term7.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial7", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial6", "stage6.bytecode_read_raf.claim.term8.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial8", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial7", "stage6.bytecode_read_raf.claim.term9.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial9", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial8", "stage6.bytecode_read_raf.claim.term10.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial10", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial9", "stage6.bytecode_read_raf.claim.term11.stage_gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial11", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial10", "stage6.bytecode_read_raf.claim.term12.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial12", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial11", "stage6.bytecode_read_raf.claim.term13.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial13", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial12", "stage6.bytecode_read_raf.claim.term14.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial14", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial13", "stage6.bytecode_read_raf.claim.term15.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial15", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial14", "stage6.bytecode_read_raf.claim.term16.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial16", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial15", "stage6.bytecode_read_raf.claim.term17.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial17", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial16", "stage6.bytecode_read_raf.claim.term18.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial18", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial17", "stage6.bytecode_read_raf.claim.term19.gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial19", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial18", "stage6.bytecode_read_raf.claim.term20.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial20", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial19", "stage6.bytecode_read_raf.claim.term21.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial21", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial20", "stage6.bytecode_read_raf.claim.term22.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial22", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial21", "stage6.bytecode_read_raf.claim.term23.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial23", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial22", "stage6.bytecode_read_raf.claim.term24.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial24", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial23", "stage6.bytecode_read_raf.claim.term25.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial25", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial24", "stage6.bytecode_read_raf.claim.term26.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial26", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial25", "stage6.bytecode_read_raf.claim.term27.gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial27", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial26", "stage6.bytecode_read_raf.claim.term28.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial28", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial27", "stage6.bytecode_read_raf.claim.term29.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial29", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial28", "stage6.bytecode_read_raf.claim.term30.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial30", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial29", "stage6.bytecode_read_raf.claim.term31.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial31", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial30", "stage6.bytecode_read_raf.claim.term32.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial32", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial31", "stage6.bytecode_read_raf.claim.term33.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial33", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial32", "stage6.bytecode_read_raf.claim.term34.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial34", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial33", "stage6.bytecode_read_raf.claim.term35.gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial35", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial34", "stage6.bytecode_read_raf.claim.term36.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial36", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial35", "stage6.bytecode_read_raf.claim.term37.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial37", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial36", "stage6.bytecode_read_raf.claim.term38.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial38", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial37", "stage6.bytecode_read_raf.claim.term39.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial39", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial38", "stage6.bytecode_read_raf.claim.term40.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial40", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial39", "stage6.bytecode_read_raf.claim.term41.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial41", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial40", "stage6.bytecode_read_raf.claim.term42.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial42", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial41", "stage6.bytecode_read_raf.claim.term43.gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial43", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial42", "stage6.bytecode_read_raf.claim.term44.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial44", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial43", "stage6.bytecode_read_raf.claim.term45.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial45", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial44", "stage6.bytecode_read_raf.claim.term46.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial46", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial45", "stage6.bytecode_read_raf.claim.term47.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial47", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial46", "stage6.bytecode_read_raf.claim.term48.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial48", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial47", "stage6.bytecode_read_raf.claim.term49.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial49", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial48", "stage6.bytecode_read_raf.claim.term50.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial50", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial49", "stage6.bytecode_read_raf.claim.term51.gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial51", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial50", "stage6.bytecode_read_raf.claim.term52.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial52", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial51", "stage6.bytecode_read_raf.claim.term53.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial53", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial52", "stage6.bytecode_read_raf.claim.term54.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial54", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial53", "stage6.bytecode_read_raf.claim.term55.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial55", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial54", "stage6.bytecode_read_raf.claim.term56.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial56", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial55", "stage6.bytecode_read_raf.claim.term57.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial57", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial56", "stage6.bytecode_read_raf.claim.term58.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial58", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial57", "stage6.bytecode_read_raf.claim.term59.gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial59", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial58", "stage6.bytecode_read_raf.claim.term60.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial60", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial59", "stage6.bytecode_read_raf.claim.term61.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial61", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial60", "stage6.bytecode_read_raf.claim.term62.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial62", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial61", "stage6.bytecode_read_raf.claim.term63.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial63", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial62", "stage6.bytecode_read_raf.claim.term64.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial64", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial63", "stage6.bytecode_read_raf.claim.term65.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial65", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial64", "stage6.bytecode_read_raf.claim.term66.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial66", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial65", "stage6.bytecode_read_raf.claim.term67.gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial67", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial66", "stage6.bytecode_read_raf.claim.term68.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial68", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial67", "stage6.bytecode_read_raf.claim.term69.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial69", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial68", "stage6.bytecode_read_raf.claim.term70.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial70", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial69", "stage6.bytecode_read_raf.claim.term71.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial71", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial70", "stage6.bytecode_read_raf.claim.term72.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial72", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial71", "stage6.bytecode_read_raf.claim.term73.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial73", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial72", "stage6.bytecode_read_raf.claim.term74.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial74", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial73", "stage6.bytecode_read_raf.claim.term75.gamma_term"]), - stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial75", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial74", "stage6.bytecode_read_raf.claim.term76.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial76", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial75", "stage6.bytecode_read_raf.claim.entry_constant"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term1.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term1.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term1.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_1"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term2.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term2.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term2.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_2"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term3.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_3"]), - stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), - stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), - stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term1.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term1.stage_gamma_pow", "stage6.input.stage1.Imm"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term2.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term2.stage_gamma_pow", "stage6.input.stage1.OpFlagAddOperands"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term3.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term3.stage_gamma_pow", "stage6.input.stage1.OpFlagSubtractOperands"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term4.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term4.stage_gamma_pow", "stage6.input.stage1.OpFlagMultiplyOperands"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term5.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term5.stage_gamma_pow", "stage6.input.stage1.OpFlagLoad"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term6.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term6.stage_gamma_pow", "stage6.input.stage1.OpFlagStore"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term7.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term7.stage_gamma_pow", "stage6.input.stage1.OpFlagJump"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term8.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term8.stage_gamma_pow", "stage6.input.stage1.OpFlagWriteLookupOutputToRD"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term9.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term9.stage_gamma_pow", "stage6.input.stage1.OpFlagVirtualInstruction"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term10.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term10.stage_gamma_pow", "stage6.input.stage1.OpFlagAssert"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term11.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term11.stage_gamma_pow", "stage6.input.stage1.OpFlagDoNotUpdateUnexpandedPC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term12.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term12.stage_gamma_pow", "stage6.input.stage1.OpFlagAdvice"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term13.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term13.stage_gamma_pow", "stage6.input.stage1.OpFlagIsCompressed"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term14.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term14.stage_gamma_pow", "stage6.input.stage1.OpFlagIsFirstInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage1_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term15.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term15.stage_gamma_pow", "stage6.input.stage1.OpFlagIsLastInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term16.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term16.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term16.gamma_pow", "stage6.input.stage2.OpFlagJump"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.stage_gamma_pow", "stage6.input.stage2.InstructionFlagBranch"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term17.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term17.gamma_pow", "stage6.bytecode_read_raf.claim.term17.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.stage_gamma_pow", "stage6.input.stage2.OpFlagWriteLookupOutputToRD"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term18.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term18.gamma_pow", "stage6.bytecode_read_raf.claim.term18.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage2_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.stage_gamma_pow", "stage6.input.stage2.OpFlagVirtualInstruction"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term19.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term19.gamma_pow", "stage6.bytecode_read_raf.claim.term19.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term20.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term20.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term20.gamma_pow", "stage6.input.stage3.instruction_input.Imm"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.stage_gamma_pow", "stage6.input.stage3.spartan_shift.UnexpandedPC"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term21.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term21.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term21.gamma_pow", "stage6.bytecode_read_raf.claim.term21.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsRs1Value"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term22.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term22.gamma_pow", "stage6.bytecode_read_raf.claim.term22.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagLeftOperandIsPC"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term23.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term23.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term23.gamma_pow", "stage6.bytecode_read_raf.claim.term23.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsRs2Value"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term24.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term24.gamma_pow", "stage6.bytecode_read_raf.claim.term24.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.stage_gamma_pow", "stage6.input.stage3.instruction_input.InstructionFlagRightOperandIsImm"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term25.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term25.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term25.gamma_pow", "stage6.bytecode_read_raf.claim.term25.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.stage_gamma_pow", "stage6.input.stage3.spartan_shift.InstructionFlagIsNoop"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term26.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term26.gamma_pow", "stage6.bytecode_read_raf.claim.term26.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagVirtualInstruction"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term27.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term27.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term27.gamma_pow", "stage6.bytecode_read_raf.claim.term27.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage3_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.stage_gamma_pow", "stage6.input.stage3.spartan_shift.OpFlagIsFirstInSequence"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term28.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term28.gamma_pow", "stage6.bytecode_read_raf.claim.term28.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term29.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term29.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term29.gamma_pow", "stage6.input.stage4.RdWa"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.stage_gamma_pow", "stage6.input.stage4.Rs1Ra"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term30.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term30.gamma_pow", "stage6.bytecode_read_raf.claim.term30.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage4_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.stage_gamma_pow", "stage6.input.stage4.Rs2Ra"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term31.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term31.gamma_pow", "stage6.bytecode_read_raf.claim.term31.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term32.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term32.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term32.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdWa"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.stage_gamma_pow", "stage6.input.stage5.InstructionRafFlag"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term33.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term33.gamma_pow", "stage6.bytecode_read_raf.claim.term33.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_0"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term34.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term34.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term34.gamma_pow", "stage6.bytecode_read_raf.claim.term34.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_1"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term35.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term35.gamma_pow", "stage6.bytecode_read_raf.claim.term35.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_2"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term36.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term36.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term36.gamma_pow", "stage6.bytecode_read_raf.claim.term36.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_3"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term37.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term37.gamma_pow", "stage6.bytecode_read_raf.claim.term37.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_4"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term38.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term38.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term38.gamma_pow", "stage6.bytecode_read_raf.claim.term38.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_5"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term39.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term39.gamma_pow", "stage6.bytecode_read_raf.claim.term39.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", Stage6FieldExprKind::Pow(8), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_6"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term40.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term40.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term40.gamma_pow", "stage6.bytecode_read_raf.claim.term40.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", Stage6FieldExprKind::Pow(9), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_7"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term41.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term41.gamma_pow", "stage6.bytecode_read_raf.claim.term41.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", Stage6FieldExprKind::Pow(10), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_8"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term42.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term42.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term42.gamma_pow", "stage6.bytecode_read_raf.claim.term42.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", Stage6FieldExprKind::Pow(11), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_9"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term43.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term43.gamma_pow", "stage6.bytecode_read_raf.claim.term43.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", Stage6FieldExprKind::Pow(12), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_10"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term44.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term44.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term44.gamma_pow", "stage6.bytecode_read_raf.claim.term44.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", Stage6FieldExprKind::Pow(13), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_11"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term45.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term45.gamma_pow", "stage6.bytecode_read_raf.claim.term45.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", Stage6FieldExprKind::Pow(14), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_12"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term46.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term46.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term46.gamma_pow", "stage6.bytecode_read_raf.claim.term46.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", Stage6FieldExprKind::Pow(15), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_13"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term47.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term47.gamma_pow", "stage6.bytecode_read_raf.claim.term47.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", Stage6FieldExprKind::Pow(16), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_14"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term48.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term48.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term48.gamma_pow", "stage6.bytecode_read_raf.claim.term48.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", Stage6FieldExprKind::Pow(17), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_15"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term49.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term49.gamma_pow", "stage6.bytecode_read_raf.claim.term49.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", Stage6FieldExprKind::Pow(18), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_16"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term50.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term50.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term50.gamma_pow", "stage6.bytecode_read_raf.claim.term50.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", Stage6FieldExprKind::Pow(19), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_17"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term51.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term51.gamma_pow", "stage6.bytecode_read_raf.claim.term51.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", Stage6FieldExprKind::Pow(20), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_18"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term52.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term52.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term52.gamma_pow", "stage6.bytecode_read_raf.claim.term52.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", Stage6FieldExprKind::Pow(21), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_19"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term53.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term53.gamma_pow", "stage6.bytecode_read_raf.claim.term53.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", Stage6FieldExprKind::Pow(22), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_20"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term54.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term54.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term54.gamma_pow", "stage6.bytecode_read_raf.claim.term54.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", Stage6FieldExprKind::Pow(23), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_21"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term55.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term55.gamma_pow", "stage6.bytecode_read_raf.claim.term55.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", Stage6FieldExprKind::Pow(24), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_22"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term56.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term56.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term56.gamma_pow", "stage6.bytecode_read_raf.claim.term56.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", Stage6FieldExprKind::Pow(25), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_23"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term57.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term57.gamma_pow", "stage6.bytecode_read_raf.claim.term57.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", Stage6FieldExprKind::Pow(26), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_24"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term58.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term58.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term58.gamma_pow", "stage6.bytecode_read_raf.claim.term58.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", Stage6FieldExprKind::Pow(27), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_25"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term59.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term59.gamma_pow", "stage6.bytecode_read_raf.claim.term59.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", Stage6FieldExprKind::Pow(28), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_26"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term60.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term60.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term60.gamma_pow", "stage6.bytecode_read_raf.claim.term60.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", Stage6FieldExprKind::Pow(29), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_27"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term61.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term61.gamma_pow", "stage6.bytecode_read_raf.claim.term61.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", Stage6FieldExprKind::Pow(30), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_28"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term62.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term62.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term62.gamma_pow", "stage6.bytecode_read_raf.claim.term62.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", Stage6FieldExprKind::Pow(31), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_29"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term63.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term63.gamma_pow", "stage6.bytecode_read_raf.claim.term63.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", Stage6FieldExprKind::Pow(32), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_30"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term64.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term64.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term64.gamma_pow", "stage6.bytecode_read_raf.claim.term64.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", Stage6FieldExprKind::Pow(33), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_31"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term65.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term65.gamma_pow", "stage6.bytecode_read_raf.claim.term65.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", Stage6FieldExprKind::Pow(34), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_32"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term66.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term66.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term66.gamma_pow", "stage6.bytecode_read_raf.claim.term66.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", Stage6FieldExprKind::Pow(35), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_33"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term67.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term67.gamma_pow", "stage6.bytecode_read_raf.claim.term67.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", Stage6FieldExprKind::Pow(36), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_34"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term68.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term68.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term68.gamma_pow", "stage6.bytecode_read_raf.claim.term68.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", Stage6FieldExprKind::Pow(37), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_35"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term69.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term69.gamma_pow", "stage6.bytecode_read_raf.claim.term69.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", Stage6FieldExprKind::Pow(38), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_36"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term70.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term70.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term70.gamma_pow", "stage6.bytecode_read_raf.claim.term70.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", Stage6FieldExprKind::Pow(39), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_37"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term71.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term71.gamma_pow", "stage6.bytecode_read_raf.claim.term71.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", Stage6FieldExprKind::Pow(40), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_38"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term72.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term72.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term72.gamma_pow", "stage6.bytecode_read_raf.claim.term72.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", Stage6FieldExprKind::Pow(41), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_39"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term73.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term73.gamma_pow", "stage6.bytecode_read_raf.claim.term73.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", Stage6FieldExprKind::Pow(42), &["stage6.bytecode_read_raf.stage5_gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.stage_gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.stage_gamma_pow", "stage6.input.stage5.LookupTableFlag_40"]), + stage6_field_expr("stage6.bytecode_read_raf.claim.term74.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term74.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term74.gamma_pow", "stage6.bytecode_read_raf.claim.term74.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term75.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term75.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term75.gamma_pow", "stage6.input.stage1.PC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term76.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim.term76.gamma_term", Stage6FieldExprKind::Mul, &["stage6.bytecode_read_raf.claim.term76.gamma_pow", "stage6.input.stage3.spartan_shift.PC"]), stage6_field_expr("stage6.bytecode_read_raf.claim.entry_constant", Stage6FieldExprKind::Pow(7), &["stage6.bytecode_read_raf.gamma"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage1.UnexpandedPC", "stage6.bytecode_read_raf.claim.term1.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial0", "stage6.bytecode_read_raf.claim.term2.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial1", "stage6.bytecode_read_raf.claim.term3.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial2", "stage6.bytecode_read_raf.claim.term4.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial3", "stage6.bytecode_read_raf.claim.term5.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial4", "stage6.bytecode_read_raf.claim.term6.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial5", "stage6.bytecode_read_raf.claim.term7.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial7", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial6", "stage6.bytecode_read_raf.claim.term8.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial8", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial7", "stage6.bytecode_read_raf.claim.term9.stage_gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial9", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial8", "stage6.bytecode_read_raf.claim.term10.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial10", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial9", "stage6.bytecode_read_raf.claim.term11.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial11", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial10", "stage6.bytecode_read_raf.claim.term12.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial12", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial11", "stage6.bytecode_read_raf.claim.term13.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial13", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial12", "stage6.bytecode_read_raf.claim.term14.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial14", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial13", "stage6.bytecode_read_raf.claim.term15.stage_gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial15", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial14", "stage6.bytecode_read_raf.claim.term16.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial16", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial15", "stage6.bytecode_read_raf.claim.term17.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial17", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial16", "stage6.bytecode_read_raf.claim.term18.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial18", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial17", "stage6.bytecode_read_raf.claim.term19.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial19", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial18", "stage6.bytecode_read_raf.claim.term20.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial20", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial19", "stage6.bytecode_read_raf.claim.term21.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial21", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial20", "stage6.bytecode_read_raf.claim.term22.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial22", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial21", "stage6.bytecode_read_raf.claim.term23.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial23", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial22", "stage6.bytecode_read_raf.claim.term24.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial24", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial23", "stage6.bytecode_read_raf.claim.term25.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial25", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial24", "stage6.bytecode_read_raf.claim.term26.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial26", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial25", "stage6.bytecode_read_raf.claim.term27.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial27", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial26", "stage6.bytecode_read_raf.claim.term28.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial28", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial27", "stage6.bytecode_read_raf.claim.term29.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial29", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial28", "stage6.bytecode_read_raf.claim.term30.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial30", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial29", "stage6.bytecode_read_raf.claim.term31.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial31", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial30", "stage6.bytecode_read_raf.claim.term32.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial32", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial31", "stage6.bytecode_read_raf.claim.term33.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial33", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial32", "stage6.bytecode_read_raf.claim.term34.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial34", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial33", "stage6.bytecode_read_raf.claim.term35.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial35", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial34", "stage6.bytecode_read_raf.claim.term36.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial36", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial35", "stage6.bytecode_read_raf.claim.term37.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial37", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial36", "stage6.bytecode_read_raf.claim.term38.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial38", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial37", "stage6.bytecode_read_raf.claim.term39.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial39", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial38", "stage6.bytecode_read_raf.claim.term40.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial40", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial39", "stage6.bytecode_read_raf.claim.term41.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial41", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial40", "stage6.bytecode_read_raf.claim.term42.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial42", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial41", "stage6.bytecode_read_raf.claim.term43.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial43", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial42", "stage6.bytecode_read_raf.claim.term44.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial44", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial43", "stage6.bytecode_read_raf.claim.term45.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial45", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial44", "stage6.bytecode_read_raf.claim.term46.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial46", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial45", "stage6.bytecode_read_raf.claim.term47.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial47", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial46", "stage6.bytecode_read_raf.claim.term48.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial48", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial47", "stage6.bytecode_read_raf.claim.term49.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial49", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial48", "stage6.bytecode_read_raf.claim.term50.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial50", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial49", "stage6.bytecode_read_raf.claim.term51.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial51", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial50", "stage6.bytecode_read_raf.claim.term52.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial52", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial51", "stage6.bytecode_read_raf.claim.term53.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial53", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial52", "stage6.bytecode_read_raf.claim.term54.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial54", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial53", "stage6.bytecode_read_raf.claim.term55.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial55", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial54", "stage6.bytecode_read_raf.claim.term56.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial56", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial55", "stage6.bytecode_read_raf.claim.term57.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial57", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial56", "stage6.bytecode_read_raf.claim.term58.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial58", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial57", "stage6.bytecode_read_raf.claim.term59.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial59", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial58", "stage6.bytecode_read_raf.claim.term60.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial60", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial59", "stage6.bytecode_read_raf.claim.term61.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial61", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial60", "stage6.bytecode_read_raf.claim.term62.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial62", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial61", "stage6.bytecode_read_raf.claim.term63.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial63", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial62", "stage6.bytecode_read_raf.claim.term64.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial64", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial63", "stage6.bytecode_read_raf.claim.term65.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial65", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial64", "stage6.bytecode_read_raf.claim.term66.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial66", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial65", "stage6.bytecode_read_raf.claim.term67.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial67", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial66", "stage6.bytecode_read_raf.claim.term68.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial68", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial67", "stage6.bytecode_read_raf.claim.term69.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial69", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial68", "stage6.bytecode_read_raf.claim.term70.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial70", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial69", "stage6.bytecode_read_raf.claim.term71.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial71", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial70", "stage6.bytecode_read_raf.claim.term72.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial72", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial71", "stage6.bytecode_read_raf.claim.term73.gamma_term"]), + stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial73", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial72", "stage6.bytecode_read_raf.claim.term74.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial74", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial73", "stage6.bytecode_read_raf.claim.term75.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial75", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial74", "stage6.bytecode_read_raf.claim.term76.gamma_term"]), stage6_field_expr("stage6.bytecode_read_raf.claim_expr.partial76", Stage6FieldExprKind::Add, &["stage6.bytecode_read_raf.claim_expr.partial75", "stage6.bytecode_read_raf.claim.entry_constant"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term1.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term1.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term1.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_1"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term2.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term2.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term2.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_2"]), + stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term3.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), + stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), + stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), + stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -454,6 +438,8 @@ pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[ Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, + Stage6PointSlicePlan { symbol: "stage6.booleanity.output.point.Address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" }, + Stage6PointSlicePlan { symbol: "stage6.booleanity.output.point.Cycle", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 16, length: 16, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" }, ]; pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[ @@ -497,6 +483,7 @@ pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[ Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_29.address", "stage6.instruction_ra_virtual.instance"] }, Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_30.address", "stage6.instruction_ra_virtual.instance"] }, Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_31.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointConcatPlan { symbol: "stage6.booleanity.output.point", layout: "address_prefix_then_cycle", arity: 20, inputs: &["stage6.booleanity.output.point.Address", "stage6.booleanity.output.point.Cycle"] }, ]; pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[ Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.bytecode_read_raf.point.BytecodeRa_0", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_0" }, @@ -590,91 +577,180 @@ pub const STAGE6_OPENING_BATCHES: &[Stage6OpeningBatchPlan] = &[ Stage6OpeningBatchPlan { symbol: "stage6.openings", stage: "stage6", proof_slot: "stage6.openings", policy: "jolt_stage6_output_order", count: 81, ordered_claims: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"], claim_operands: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"] }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.hamming_booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage1.LookupOutput", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.booleanity.output.eq.InstructionRa0", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.output.point", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.hamming_booleanity.output.eq.LookupOutput"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_1_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_2_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_3_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_4_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_5_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_6_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_7_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_8_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_9_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_10_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_11_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_12_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_13_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_14_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_15_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_16_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_17_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_18_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_19_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_20_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_21_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_22_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_23_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_24_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_25_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_26_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_27_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_28_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_29_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_30_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_31_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_32_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_33_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_34_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_35_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_36_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_37_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_38_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.hamming_booleanity.eval.HammingWeight", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_0", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 2, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_1", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_1_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 4, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_2", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_2_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 6, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_3", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_3_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 8, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_4", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_4_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 10, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_5", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_5_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 12, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_6", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_6_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 14, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_7", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_7_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 16, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_8", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_8_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 18, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_9", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_9_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 20, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_10", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_10_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 22, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_11", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_11_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 24, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_12", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_12_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 26, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_13", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_13_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 28, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_14", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_14_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 30, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_15", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_15_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 32, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_16", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_16_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 34, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_17", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_17_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 36, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_18", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_18_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 38, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_19", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_19_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 40, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_20", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_20_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 42, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_21", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_21_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 44, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_22", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_22_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 46, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_23", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_23_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 48, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_24", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_24_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 50, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_25", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_25_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 52, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_26", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_26_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 54, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_27", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_27_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 56, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_28", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_28_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 58, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_29", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_29_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 60, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_30", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_30_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 62, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_31", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_31_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 64, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_0", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_32_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 66, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_1", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_33_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 68, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_2", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_34_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 70, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_0", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_35_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 72, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_1", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_36_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 74, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_2", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_37_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 76, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_3", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_38_FACTORS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: "stage6.hamming_booleanity.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: "stage6.booleanity.output.family", gamma: Some("stage6.booleanity.gamma"), terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.ram_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.hamming_booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage1.LookupOutput", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.ram_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERM_0_FACTORS }, +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.hamming_booleanity.output.eq.LookupOutput"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.hamming_booleanity.eval.HammingWeight", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILY_0_TERM_0_FACTORS }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILY_0_TERMS }, +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan] = &[ + bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: "stage6.hamming_booleanity.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILY_0_TERMS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.instruction_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.ram_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.ram_ra_virtual.output.eq.Cycle"]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 3, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 4, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 5, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 6, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_FACTORS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: Some("stage6.instruction_ra_virtual.gamma"), terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.instruction_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, +]; + +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_1_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_1_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_2_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_2_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_3_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_3_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_4_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_4_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_5_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_5_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_6_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_6_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_7_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_7_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_1_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_1_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_2_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_2_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 3, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_3_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_3_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 4, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_4_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_4_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 5, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_5_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_5_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 6, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_6_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_6_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_7_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_7_FACTORS }, +]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: Some("stage6.instruction_ra_virtual.gamma"), terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERMS }, +]; + +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage2.ram_read_write.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.ram_val_check.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.registers_read_write.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.registers_val_evaluation.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_EVALS: &[&str] = &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.eval.RdInc"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_VALUE_TERM_OFFSETS: &[usize] = &[]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan] = &[ +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_EVALS: &[&str] = &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.eval.RdInc"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_VALUE_TERM_OFFSETS: &[usize] = &[]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan] = &[ ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERM_0_FACTORS: &[&str] = &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERM_1_FACTORS: &[&str] = &["stage6.inc_claim_reduction.output.eq.RamIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 0, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERM_0_FACTORS }, - bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 1, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERM_1_FACTORS }, +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERM_0_FACTORS: &[&str] = &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERM_1_FACTORS: &[&str] = &["stage6.inc_claim_reduction.output.eq.RamIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 0, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 1, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERM_1_FACTORS }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage6.inc_claim_reduction.output.family", gamma: "stage6.inc_claim_reduction.gamma", evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_EVALS, power_stride: 2, value_term_offsets: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_VALUE_TERM_OFFSETS, shared_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_SHARED_TERMS, item_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILY_0_ITEM_TERMS }, +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan] = &[ + bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage6.inc_claim_reduction.output.family", gamma: "stage6.inc_claim_reduction.gamma", evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_EVALS, power_stride: 2, value_term_offsets: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_VALUE_TERM_OFFSETS, shared_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_SHARED_TERMS, item_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERMS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[ - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES, claim_value: "stage6.hamming_booleanity.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.ram_ra_virtual.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.instruction_ra_virtual.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_FAMILIES, product_families: &[], function_families: &[], claim_value: "stage6.inc_claim_reduction.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6Booleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES, claim_value: "stage6.booleanity.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILIES, claim_value: "stage6.hamming_booleanity.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.ram_ra_virtual.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.instruction_ra_virtual.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES, product_families: &[], function_families: &[], claim_value: "stage6.inc_claim_reduction.output.family" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { @@ -987,10 +1063,8 @@ fn expected_batched_output_claim( })?; expected_bytecode_read_raf(program, data, store, evals, local_point)? } - Stage6RelationKind::Stage6Booleanity => { - expected_booleanity(program, store, evals, local_point)? - } - Stage6RelationKind::Stage6HammingBooleanity + Stage6RelationKind::Stage6Booleanity + | Stage6RelationKind::Stage6HammingBooleanity | Stage6RelationKind::Stage6RamRaVirtual | Stage6RelationKind::Stage6InstructionRaVirtual | Stage6RelationKind::Stage6IncClaimReduction => expected_plan_output_claim( @@ -1051,16 +1125,6 @@ fn expected_bytecode_read_raf( )?) } -fn expected_booleanity( - program: &'static Stage6VerifierProgramPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - let log_t = stage6_trace_rounds(program)?; - Ok(expected_stage67_booleanity(store, evals, local_point, log_t, &STAGE6_RELATION_SYMBOLS)?) -} - fn stage6_trace_rounds( program: &'static Stage6VerifierProgramPlan, ) -> Result { From ce0d3450ed8fed468f4d1cf86dfbac8f95251aed Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 20:02:55 -0600 Subject: [PATCH 040/171] refactor(bolt): plan bytecode read raf encoding Replace the remaining Stage 6 expected_stage67 bytecode helper with typed bytecode read-RAF plan rows. Keep the Jolt-specific evaluator quarantined in Tier B, regenerate Stage 6 verifier artifacts, and add regression coverage against the stale helper/symbol path. --- .../src/protocols/jolt/emit/rust/stage6.rs | 87 +++- .../jolt/verifier_jolt_relations.rs.template | 394 +++++++++++------- crates/bolt/tests/commitment_ir.rs | 17 + crates/bolt/tests/verifier_cleanup.rs | 1 + .../src/stages/jolt_relations.rs | 394 +++++++++++------- crates/jolt-verifier/src/stages/stage6.rs | 87 +++- 6 files changed, 650 insertions(+), 330 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 136322124d..a0e3f598ca 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1142,7 +1142,7 @@ impl Stage6CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ - use super::jolt_relations::{expected_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols};\n\ + use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeEntryContributionPlan, Stage67BytecodeFlag, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -1461,31 +1461,72 @@ const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { hamming_booleanity_instance: "stage6.hamming_booleanity.instance", }; -const STAGE6_BYTECODE_SYMBOLS: Stage67BytecodeSymbols = Stage67BytecodeSymbols { +const STAGE6_BYTECODE_STAGE1_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::Address { gamma_power: 0 }, + Stage67BytecodeTermPlan::Imm { gamma_power: 1 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 0, gamma_power: 2 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 1, gamma_power: 3 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 2, gamma_power: 4 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 3, gamma_power: 5 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 4, gamma_power: 6 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 7 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 8 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 9 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 8, gamma_power: 10 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 9, gamma_power: 11 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 10, gamma_power: 12 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 11, gamma_power: 13 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 14 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 13, gamma_power: 15 }, +]; +const STAGE6_BYTECODE_STAGE2_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 0 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsBranch, expected: true, gamma_power: 1 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 2 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 3 }, +]; +const STAGE6_BYTECODE_STAGE3_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::Imm { gamma_power: 0 }, + Stage67BytecodeTermPlan::Address { gamma_power: 1 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsRs1, expected: true, gamma_power: 2 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsPc, expected: true, gamma_power: 3 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsRs2, expected: true, gamma_power: 4 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsImm, expected: true, gamma_power: 5 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsNoop, expected: true, gamma_power: 6 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 7 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 8 }, +]; +const STAGE6_BYTECODE_STAGE4_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 }, + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs1, gamma_power: 1 }, + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs2, gamma_power: 2 }, +]; +const STAGE6_BYTECODE_STAGE5_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsInterleaved, expected: false, gamma_power: 1 }, + Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }, +]; +const STAGE6_BYTECODE_STAGES: &[Stage67BytecodeStagePlan] = &[ + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage1_gamma", cycle_point: "stage6.input.stage1.Imm", register_point: None, output_gamma_power: 0, identity_gamma_power: Some(5), terms: STAGE6_BYTECODE_STAGE1_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage2_gamma", cycle_point: "stage6.input.stage2.OpFlagJump", register_point: None, output_gamma_power: 1, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE2_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage3_gamma", cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC", register_point: None, output_gamma_power: 2, identity_gamma_power: Some(4), terms: STAGE6_BYTECODE_STAGE3_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage4_gamma", cycle_point: "stage6.input.stage4.Rs1Ra", register_point: Some("stage6.input.stage4.Rs1Ra"), output_gamma_power: 3, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE4_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage5_gamma", cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa", register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"), output_gamma_power: 4, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE5_TERMS }, +]; + +const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { point: "stage6.bytecode_read_raf.point", gamma: "stage6.bytecode_read_raf.gamma", bytecode_ra_eval_prefix: "stage6.bytecode_read_raf.eval.BytecodeRa_", entries: "stage6.bytecode_read_raf.entries", entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", - stage_gammas: [ - "stage6.bytecode_read_raf.stage1_gamma", - "stage6.bytecode_read_raf.stage2_gamma", - "stage6.bytecode_read_raf.stage3_gamma", - "stage6.bytecode_read_raf.stage4_gamma", - "stage6.bytecode_read_raf.stage5_gamma", - ], - stage_cycle_points: [ - "stage6.input.stage1.Imm", - "stage6.input.stage2.OpFlagJump", - "stage6.input.stage3.spartan_shift.UnexpandedPC", - "stage6.input.stage4.Rs1Ra", - "stage6.input.stage5.registers_val_evaluation.RdWa", - ], - stage4_register_point: "stage6.input.stage4.Rs1Ra", - stage5_register_point: "stage6.input.stage5.registers_val_evaluation.RdWa", - entry_rd: "stage6.bytecode.entry.rd", - entry_rs1: "stage6.bytecode.entry.rs1", - entry_rs2: "stage6.bytecode.entry.rs2", + stages: STAGE6_BYTECODE_STAGES, + entry_contribution: Stage67BytecodeEntryContributionPlan { gamma_power: 7 }, + registers: Stage67BytecodeRegisterSymbols { + rd: "stage6.bytecode.entry.rd", + rs1: "stage6.bytecode.entry.rs1", + rs2: "stage6.bytecode.entry.rs2", + }, entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; @@ -2596,7 +2637,8 @@ fn expected_bytecode_read_raf( local_point: &[Fr], ) -> Result { let log_t = stage6_trace_rounds(program)?; - Ok(expected_stage67_bytecode_read_raf( + Ok(evaluate_stage67_bytecode_read_raf( + &STAGE6_BYTECODE_PLAN, &data.entries, data.entry_bytecode_index, data.num_lookup_tables, @@ -2604,7 +2646,6 @@ fn expected_bytecode_read_raf( evals, local_point, log_t, - &STAGE6_BYTECODE_SYMBOLS, )?) } diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 3a7784cc1d..678922cbf3 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -12,8 +12,7 @@ //! - point normalizations for the Jolt bytecode and instruction RA //! read-RAF lookup arguments //! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement -//! - the remaining `expected_stage67_*` relation evaluator for the Stage 6 -//! bytecode-read-RAF relation +//! - typed bytecode read-RAF plan data and its small Jolt-specific evaluator //! - the small Jolt-specific field-math helpers //! (`operand_polynomial_eval`, `identity_polynomial_eval`, //! `lt_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt @@ -89,22 +88,84 @@ pub struct Stage67RelationSymbols { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage67BytecodeSymbols { +pub struct Stage67BytecodeReadRafPlan { pub point: &'static str, pub gamma: &'static str, pub bytecode_ra_eval_prefix: &'static str, pub entries: &'static str, pub entry_bytecode_index: &'static str, - pub stage_gammas: [&'static str; 5], - pub stage_cycle_points: [&'static str; 5], - pub stage4_register_point: &'static str, - pub stage5_register_point: &'static str, - pub entry_rd: &'static str, - pub entry_rs1: &'static str, - pub entry_rs2: &'static str, + pub stages: &'static [Stage67BytecodeStagePlan], + pub entry_contribution: Stage67BytecodeEntryContributionPlan, + pub registers: Stage67BytecodeRegisterSymbols, pub entry_lookup_table: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage67BytecodeStagePlan { + pub gamma: &'static str, + pub cycle_point: &'static str, + pub register_point: Option<&'static str>, + pub output_gamma_power: usize, + pub identity_gamma_power: Option, + pub terms: &'static [Stage67BytecodeTermPlan], +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage67BytecodeEntryContributionPlan { + pub gamma_power: usize, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage67BytecodeRegisterSymbols { + pub rd: &'static str, + pub rs1: &'static str, + pub rs2: &'static str, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage67BytecodeTermPlan { + Address { + gamma_power: usize, + }, + Imm { + gamma_power: usize, + }, + CircuitFlag { + index: usize, + gamma_power: usize, + }, + EntryFlag { + flag: Stage67BytecodeFlag, + expected: bool, + gamma_power: usize, + }, + RegisterEq { + register: Stage67BytecodeRegister, + gamma_power: usize, + }, + LookupTable { + gamma_base: usize, + }, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage67BytecodeFlag { + IsInterleaved, + IsBranch, + LeftIsRs1, + LeftIsPc, + RightIsRs2, + RightIsImm, + IsNoop, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage67BytecodeRegister { + Rd, + Rs1, + Rs2, +} + pub trait Stage67BytecodeEntry { fn address(&self) -> Fr; fn imm(&self) -> Fr; @@ -135,7 +196,8 @@ pub fn stage67_trace_rounds( }) } -pub fn expected_stage67_bytecode_read_raf( +pub fn evaluate_stage67_bytecode_read_raf( + plan: &Stage67BytecodeReadRafPlan, entries: &[E], entry_bytecode_index: usize, num_lookup_tables: usize, @@ -143,127 +205,115 @@ pub fn expected_stage67_bytecode_read_raf( evals: &[StageNamedEval], local_point: &[Fr], log_t: usize, - symbols: &Stage67BytecodeSymbols, ) -> Result { - let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, symbols.point)?; + let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, plan.point)?; let log_k = opening_point.len() - log_t; let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k); - let gamma = store_scalar(store, symbols.gamma)?; + let gamma = store_scalar(store, plan.gamma)?; let gamma_powers = bytecode_gamma_powers(gamma); let int_eval = identity_polynomial_eval(r_address_prime); let stage_value_evals = stage67_bytecode_stage_value_evals( + plan, entries, entry_bytecode_index, num_lookup_tables, store, r_address_prime, r_cycle_prime.len(), - symbols, )?; - let stage_cycle_points = - stage67_bytecode_stage_cycle_points(store, r_cycle_prime.len(), symbols)?; - let int_contrib = [ - gamma_powers[5] * int_eval, - Fr::from_u64(0), - gamma_powers[4] * int_eval, - Fr::from_u64(0), - Fr::from_u64(0), - ]; let mut val = Fr::from_u64(0); - for index in 0..stage_value_evals.len() { - val += (stage_value_evals[index] + int_contrib[index]) - * EqPolynomial::::mle(&stage_cycle_points[index], r_cycle_prime) - * gamma_powers[index]; + for (index, stage) in plan.stages.iter().enumerate() { + let cycle_point = stage67_bytecode_stage_cycle_point(store, stage, r_cycle_prime.len())?; + let int_contrib = stage + .identity_gamma_power + .map_or(Fr::from_u64(0), |power| gamma_powers[power] * int_eval); + val += (stage_value_evals[index] + int_contrib) + * EqPolynomial::::mle(&cycle_point, r_cycle_prime) + * gamma_powers[stage.output_gamma_power]; } let entry_bits = (0..log_k) .map(|index| Fr::from_u64(((entry_bytecode_index >> (log_k - 1 - index)) & 1) as u64)) .collect::>(); let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; - let entry_contrib = gamma_powers[7] + let entry_contrib = gamma_powers[plan.entry_contribution.gamma_power] * EqPolynomial::::mle(&entry_bits, r_address_prime) * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); - let bytecode_ra = indexed_evals_by_prefix_any(evals, symbols.bytecode_ra_eval_prefix)? + let bytecode_ra = indexed_evals_by_prefix_any(evals, plan.bytecode_ra_eval_prefix)? .into_iter() .product::(); Ok((val + entry_contrib) * bytecode_ra) } -fn stage67_bytecode_stage_cycle_points( +fn stage67_bytecode_stage_cycle_point( store: &ValueStore, + stage: &Stage67BytecodeStagePlan, log_t: usize, - symbols: &Stage67BytecodeSymbols, -) -> Result<[Vec; 5], RuntimePlanError> { - let point = |index| { - let symbol = symbols.stage_cycle_points[index]; - suffix_point(store_point(store, symbol)?, log_t, symbol).map(|point| point.to_vec()) - }; - Ok([point(0)?, point(1)?, point(2)?, point(3)?, point(4)?]) +) -> Result, RuntimePlanError> { + suffix_point( + store_point(store, stage.cycle_point)?, + log_t, + stage.cycle_point, + ) + .map(|point| point.to_vec()) } fn stage67_bytecode_stage_value_evals( + plan: &Stage67BytecodeReadRafPlan, entries: &[E], entry_bytecode_index: usize, num_lookup_tables: usize, store: &ValueStore, r_address: &[Fr], log_t: usize, - symbols: &Stage67BytecodeSymbols, -) -> Result<[Fr; 5], RuntimePlanError> { +) -> Result, RuntimePlanError> { let expected_len = 1usize .checked_shl(r_address.len() as u32) .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.entries, + input: plan.entries, expected: usize::BITS as usize, actual: r_address.len(), })?; if entries.len() != expected_len { return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entries, + input: plan.entries, expected: expected_len, actual: entries.len(), }); } if entry_bytecode_index >= expected_len { return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entry_bytecode_index, + input: plan.entry_bytecode_index, expected: expected_len, actual: entry_bytecode_index + 1, }); } - let stage1_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[0])?, 16); - let stage2_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[1])?, 4); - let stage3_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[2])?, 9); - let stage4_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[3])?, 3); - let stage5_gamma_powers = field_powers( - store_scalar(store, symbols.stage_gammas[4])?, - num_lookup_tables + 2, - ); - - let stage4_register_point = - stage67_register_prefix_point(store, symbols.stage4_register_point, log_t)?; - let stage5_register_point = - stage67_register_prefix_point(store, symbols.stage5_register_point, log_t)?; - - let mut evals = [Fr::from_u64(0); 5]; + let stage_contexts = plan + .stages + .iter() + .map(|stage| { + Ok(Stage67BytecodeStageContext { + plan: stage, + gamma_powers: field_powers( + store_scalar(store, stage.gamma)?, + stage67_bytecode_stage_gamma_power_count(stage, num_lookup_tables), + ), + register_point: match stage.register_point { + Some(symbol) => Some(stage67_register_prefix_point(store, symbol, log_t)?), + None => None, + }, + }) + }) + .collect::, RuntimePlanError>>()?; + + let mut evals = vec![Fr::from_u64(0); plan.stages.len()]; for (index, entry) in entries.iter().enumerate() { let eq = indexed_boolean_eq(index, r_address); - let values = stage67_bytecode_entry_stage_values( - entry, - num_lookup_tables, - stage4_register_point, - stage5_register_point, - &stage1_gamma_powers, - &stage2_gamma_powers, - &stage3_gamma_powers, - &stage4_gamma_powers, - &stage5_gamma_powers, - symbols, - )?; + let values = stage67_bytecode_entry_stage_values(plan, entry, &stage_contexts)?; for stage in 0..evals.len() { evals[stage] += eq * values[stage]; } @@ -271,87 +321,147 @@ fn stage67_bytecode_stage_value_evals( Ok(evals) } +struct Stage67BytecodeStageContext<'a> { + plan: &'a Stage67BytecodeStagePlan, + gamma_powers: Vec, + register_point: Option<&'a [Fr]>, +} + fn stage67_bytecode_entry_stage_values( + plan: &Stage67BytecodeReadRafPlan, entry: &E, - num_lookup_tables: usize, - stage4_register_point: &[Fr], - stage5_register_point: &[Fr], - stage1_gamma_powers: &[Fr], - stage2_gamma_powers: &[Fr], - stage3_gamma_powers: &[Fr], - stage4_gamma_powers: &[Fr], - stage5_gamma_powers: &[Fr], - symbols: &Stage67BytecodeSymbols, -) -> Result<[Fr; 5], RuntimePlanError> { - let flags = entry.circuit_flags(); - let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1]; - for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) { - if *flag { - stage1 += *gamma; - } - } + stage_contexts: &[Stage67BytecodeStageContext<'_>], +) -> Result, RuntimePlanError> { + stage_contexts + .iter() + .map(|context| stage67_bytecode_entry_stage_value(plan, entry, context)) + .collect() +} - let mut stage2 = Fr::from_u64(0); - if flags[5] { - stage2 += stage2_gamma_powers[0]; - } - if entry.is_branch() { - stage2 += stage2_gamma_powers[1]; - } - if flags[6] { - stage2 += stage2_gamma_powers[2]; - } - if flags[7] { - stage2 += stage2_gamma_powers[3]; +fn stage67_bytecode_entry_stage_value( + plan: &Stage67BytecodeReadRafPlan, + entry: &E, + context: &Stage67BytecodeStageContext<'_>, +) -> Result { + let mut value = Fr::from_u64(0); + for term in context.plan.terms { + value += match *term { + Stage67BytecodeTermPlan::Address { gamma_power } => { + entry.address() * context.gamma_powers[gamma_power] + } + Stage67BytecodeTermPlan::Imm { gamma_power } => { + entry.imm() * context.gamma_powers[gamma_power] + } + Stage67BytecodeTermPlan::CircuitFlag { index, gamma_power } => { + if entry.circuit_flags()[index] { + context.gamma_powers[gamma_power] + } else { + Fr::from_u64(0) + } + } + Stage67BytecodeTermPlan::EntryFlag { + flag, + expected, + gamma_power, + } => { + if stage67_bytecode_entry_flag(entry, flag) == expected { + context.gamma_powers[gamma_power] + } else { + Fr::from_u64(0) + } + } + Stage67BytecodeTermPlan::RegisterEq { + register, + gamma_power, + } => { + let register_point = + context + .register_point + .ok_or(RuntimePlanError::MissingValue { + symbol: context.plan.cycle_point, + })?; + stage67_register_eq( + stage67_bytecode_entry_register(entry, register), + register_point, + stage67_bytecode_register_symbol(plan, register), + )? * context.gamma_powers[gamma_power] + } + Stage67BytecodeTermPlan::LookupTable { gamma_base } => { + let Some(table) = entry.lookup_table() else { + continue; + }; + if table >= plan_lookup_table_count(context, gamma_base) { + return Err(RuntimePlanError::InvalidInputLength { + input: plan.entry_lookup_table, + expected: plan_lookup_table_count(context, gamma_base), + actual: table + 1, + }); + } + context.gamma_powers[gamma_base + table] + } + }; } + Ok(value) +} - let mut stage3 = entry.imm() + entry.address() * stage3_gamma_powers[1]; - if entry.left_is_rs1() { - stage3 += stage3_gamma_powers[2]; - } - if entry.left_is_pc() { - stage3 += stage3_gamma_powers[3]; - } - if entry.right_is_rs2() { - stage3 += stage3_gamma_powers[4]; - } - if entry.right_is_imm() { - stage3 += stage3_gamma_powers[5]; - } - if entry.is_noop() { - stage3 += stage3_gamma_powers[6]; - } - if flags[7] { - stage3 += stage3_gamma_powers[7]; - } - if flags[12] { - stage3 += stage3_gamma_powers[8]; - } +fn stage67_bytecode_stage_gamma_power_count( + stage: &Stage67BytecodeStagePlan, + num_lookup_tables: usize, +) -> usize { + stage + .terms + .iter() + .map(|term| match *term { + Stage67BytecodeTermPlan::Address { gamma_power } + | Stage67BytecodeTermPlan::Imm { gamma_power } + | Stage67BytecodeTermPlan::CircuitFlag { gamma_power, .. } + | Stage67BytecodeTermPlan::EntryFlag { gamma_power, .. } + | Stage67BytecodeTermPlan::RegisterEq { gamma_power, .. } => gamma_power + 1, + Stage67BytecodeTermPlan::LookupTable { gamma_base } => gamma_base + num_lookup_tables, + }) + .max() + .unwrap_or(0) +} + +fn plan_lookup_table_count(context: &Stage67BytecodeStageContext<'_>, gamma_base: usize) -> usize { + context.gamma_powers.len().saturating_sub(gamma_base) +} - let stage4 = stage67_register_eq(entry.rd(), stage4_register_point, symbols.entry_rd)? - * stage4_gamma_powers[0] - + stage67_register_eq(entry.rs1(), stage4_register_point, symbols.entry_rs1)? - * stage4_gamma_powers[1] - + stage67_register_eq(entry.rs2(), stage4_register_point, symbols.entry_rs2)? - * stage4_gamma_powers[2]; - - let mut stage5 = stage67_register_eq(entry.rd(), stage5_register_point, symbols.entry_rd)? - * stage5_gamma_powers[0]; - if !entry.is_interleaved() { - stage5 += stage5_gamma_powers[1]; +fn stage67_bytecode_entry_flag( + entry: &E, + flag: Stage67BytecodeFlag, +) -> bool { + match flag { + Stage67BytecodeFlag::IsInterleaved => entry.is_interleaved(), + Stage67BytecodeFlag::IsBranch => entry.is_branch(), + Stage67BytecodeFlag::LeftIsRs1 => entry.left_is_rs1(), + Stage67BytecodeFlag::LeftIsPc => entry.left_is_pc(), + Stage67BytecodeFlag::RightIsRs2 => entry.right_is_rs2(), + Stage67BytecodeFlag::RightIsImm => entry.right_is_imm(), + Stage67BytecodeFlag::IsNoop => entry.is_noop(), } - if let Some(table) = entry.lookup_table() { - if table >= num_lookup_tables { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entry_lookup_table, - expected: num_lookup_tables, - actual: table + 1, - }); - } - stage5 += stage5_gamma_powers[2 + table]; +} + +fn stage67_bytecode_entry_register( + entry: &E, + register: Stage67BytecodeRegister, +) -> Option { + match register { + Stage67BytecodeRegister::Rd => entry.rd(), + Stage67BytecodeRegister::Rs1 => entry.rs1(), + Stage67BytecodeRegister::Rs2 => entry.rs2(), } +} - Ok([stage1, stage2, stage3, stage4, stage5]) +fn stage67_bytecode_register_symbol( + plan: &Stage67BytecodeReadRafPlan, + register: Stage67BytecodeRegister, +) -> &'static str { + match register { + Stage67BytecodeRegister::Rd => plan.registers.rd, + Stage67BytecodeRegister::Rs1 => plan.registers.rs1, + Stage67BytecodeRegister::Rs2 => plan.registers.rs2, + } } fn stage67_register_eq( diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 5f7ef8f715..8795cd9c40 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1808,6 +1808,23 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("expected_bytecode_read_raf")); + assert!(verifier_source.source.contains("STAGE6_BYTECODE_PLAN")); + assert!(verifier_source + .source + .contains("Stage67BytecodeReadRafPlan")); + assert!(verifier_source + .source + .contains("Stage67BytecodeTermPlan::LookupTable")); + assert!(verifier_source + .source + .contains("Stage67BytecodeTermPlan::RegisterEq")); + assert!(verifier_source + .source + .contains("evaluate_stage67_bytecode_read_raf")); + assert!(!verifier_source + .source + .contains("expected_stage67_bytecode_read_raf")); + assert!(!verifier_source.source.contains("Stage67BytecodeSymbols")); assert!(verifier_source .source .contains("stage6.bytecode_read_raf.data")); diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 4fb644c606..19c17e8615 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -398,6 +398,7 @@ fn stage67_output_plan_cutover_removed_obsolete_relation_helpers() { for path in relation_sources { let source = std::fs::read_to_string(&path).expect("read Jolt relation source"); for stale in [ + "expected_stage67_bytecode_read_raf", "expected_stage67_booleanity", "expected_stage67_hamming_booleanity", "expected_stage67_ram_ra_virtual", diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 3a7784cc1d..678922cbf3 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -12,8 +12,7 @@ //! - point normalizations for the Jolt bytecode and instruction RA //! read-RAF lookup arguments //! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement -//! - the remaining `expected_stage67_*` relation evaluator for the Stage 6 -//! bytecode-read-RAF relation +//! - typed bytecode read-RAF plan data and its small Jolt-specific evaluator //! - the small Jolt-specific field-math helpers //! (`operand_polynomial_eval`, `identity_polynomial_eval`, //! `lt_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt @@ -89,22 +88,84 @@ pub struct Stage67RelationSymbols { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage67BytecodeSymbols { +pub struct Stage67BytecodeReadRafPlan { pub point: &'static str, pub gamma: &'static str, pub bytecode_ra_eval_prefix: &'static str, pub entries: &'static str, pub entry_bytecode_index: &'static str, - pub stage_gammas: [&'static str; 5], - pub stage_cycle_points: [&'static str; 5], - pub stage4_register_point: &'static str, - pub stage5_register_point: &'static str, - pub entry_rd: &'static str, - pub entry_rs1: &'static str, - pub entry_rs2: &'static str, + pub stages: &'static [Stage67BytecodeStagePlan], + pub entry_contribution: Stage67BytecodeEntryContributionPlan, + pub registers: Stage67BytecodeRegisterSymbols, pub entry_lookup_table: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage67BytecodeStagePlan { + pub gamma: &'static str, + pub cycle_point: &'static str, + pub register_point: Option<&'static str>, + pub output_gamma_power: usize, + pub identity_gamma_power: Option, + pub terms: &'static [Stage67BytecodeTermPlan], +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage67BytecodeEntryContributionPlan { + pub gamma_power: usize, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage67BytecodeRegisterSymbols { + pub rd: &'static str, + pub rs1: &'static str, + pub rs2: &'static str, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage67BytecodeTermPlan { + Address { + gamma_power: usize, + }, + Imm { + gamma_power: usize, + }, + CircuitFlag { + index: usize, + gamma_power: usize, + }, + EntryFlag { + flag: Stage67BytecodeFlag, + expected: bool, + gamma_power: usize, + }, + RegisterEq { + register: Stage67BytecodeRegister, + gamma_power: usize, + }, + LookupTable { + gamma_base: usize, + }, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage67BytecodeFlag { + IsInterleaved, + IsBranch, + LeftIsRs1, + LeftIsPc, + RightIsRs2, + RightIsImm, + IsNoop, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage67BytecodeRegister { + Rd, + Rs1, + Rs2, +} + pub trait Stage67BytecodeEntry { fn address(&self) -> Fr; fn imm(&self) -> Fr; @@ -135,7 +196,8 @@ pub fn stage67_trace_rounds( }) } -pub fn expected_stage67_bytecode_read_raf( +pub fn evaluate_stage67_bytecode_read_raf( + plan: &Stage67BytecodeReadRafPlan, entries: &[E], entry_bytecode_index: usize, num_lookup_tables: usize, @@ -143,127 +205,115 @@ pub fn expected_stage67_bytecode_read_raf( evals: &[StageNamedEval], local_point: &[Fr], log_t: usize, - symbols: &Stage67BytecodeSymbols, ) -> Result { - let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, symbols.point)?; + let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, plan.point)?; let log_k = opening_point.len() - log_t; let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k); - let gamma = store_scalar(store, symbols.gamma)?; + let gamma = store_scalar(store, plan.gamma)?; let gamma_powers = bytecode_gamma_powers(gamma); let int_eval = identity_polynomial_eval(r_address_prime); let stage_value_evals = stage67_bytecode_stage_value_evals( + plan, entries, entry_bytecode_index, num_lookup_tables, store, r_address_prime, r_cycle_prime.len(), - symbols, )?; - let stage_cycle_points = - stage67_bytecode_stage_cycle_points(store, r_cycle_prime.len(), symbols)?; - let int_contrib = [ - gamma_powers[5] * int_eval, - Fr::from_u64(0), - gamma_powers[4] * int_eval, - Fr::from_u64(0), - Fr::from_u64(0), - ]; let mut val = Fr::from_u64(0); - for index in 0..stage_value_evals.len() { - val += (stage_value_evals[index] + int_contrib[index]) - * EqPolynomial::::mle(&stage_cycle_points[index], r_cycle_prime) - * gamma_powers[index]; + for (index, stage) in plan.stages.iter().enumerate() { + let cycle_point = stage67_bytecode_stage_cycle_point(store, stage, r_cycle_prime.len())?; + let int_contrib = stage + .identity_gamma_power + .map_or(Fr::from_u64(0), |power| gamma_powers[power] * int_eval); + val += (stage_value_evals[index] + int_contrib) + * EqPolynomial::::mle(&cycle_point, r_cycle_prime) + * gamma_powers[stage.output_gamma_power]; } let entry_bits = (0..log_k) .map(|index| Fr::from_u64(((entry_bytecode_index >> (log_k - 1 - index)) & 1) as u64)) .collect::>(); let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; - let entry_contrib = gamma_powers[7] + let entry_contrib = gamma_powers[plan.entry_contribution.gamma_power] * EqPolynomial::::mle(&entry_bits, r_address_prime) * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); - let bytecode_ra = indexed_evals_by_prefix_any(evals, symbols.bytecode_ra_eval_prefix)? + let bytecode_ra = indexed_evals_by_prefix_any(evals, plan.bytecode_ra_eval_prefix)? .into_iter() .product::(); Ok((val + entry_contrib) * bytecode_ra) } -fn stage67_bytecode_stage_cycle_points( +fn stage67_bytecode_stage_cycle_point( store: &ValueStore, + stage: &Stage67BytecodeStagePlan, log_t: usize, - symbols: &Stage67BytecodeSymbols, -) -> Result<[Vec; 5], RuntimePlanError> { - let point = |index| { - let symbol = symbols.stage_cycle_points[index]; - suffix_point(store_point(store, symbol)?, log_t, symbol).map(|point| point.to_vec()) - }; - Ok([point(0)?, point(1)?, point(2)?, point(3)?, point(4)?]) +) -> Result, RuntimePlanError> { + suffix_point( + store_point(store, stage.cycle_point)?, + log_t, + stage.cycle_point, + ) + .map(|point| point.to_vec()) } fn stage67_bytecode_stage_value_evals( + plan: &Stage67BytecodeReadRafPlan, entries: &[E], entry_bytecode_index: usize, num_lookup_tables: usize, store: &ValueStore, r_address: &[Fr], log_t: usize, - symbols: &Stage67BytecodeSymbols, -) -> Result<[Fr; 5], RuntimePlanError> { +) -> Result, RuntimePlanError> { let expected_len = 1usize .checked_shl(r_address.len() as u32) .ok_or(RuntimePlanError::InvalidInputLength { - input: symbols.entries, + input: plan.entries, expected: usize::BITS as usize, actual: r_address.len(), })?; if entries.len() != expected_len { return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entries, + input: plan.entries, expected: expected_len, actual: entries.len(), }); } if entry_bytecode_index >= expected_len { return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entry_bytecode_index, + input: plan.entry_bytecode_index, expected: expected_len, actual: entry_bytecode_index + 1, }); } - let stage1_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[0])?, 16); - let stage2_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[1])?, 4); - let stage3_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[2])?, 9); - let stage4_gamma_powers = field_powers(store_scalar(store, symbols.stage_gammas[3])?, 3); - let stage5_gamma_powers = field_powers( - store_scalar(store, symbols.stage_gammas[4])?, - num_lookup_tables + 2, - ); - - let stage4_register_point = - stage67_register_prefix_point(store, symbols.stage4_register_point, log_t)?; - let stage5_register_point = - stage67_register_prefix_point(store, symbols.stage5_register_point, log_t)?; - - let mut evals = [Fr::from_u64(0); 5]; + let stage_contexts = plan + .stages + .iter() + .map(|stage| { + Ok(Stage67BytecodeStageContext { + plan: stage, + gamma_powers: field_powers( + store_scalar(store, stage.gamma)?, + stage67_bytecode_stage_gamma_power_count(stage, num_lookup_tables), + ), + register_point: match stage.register_point { + Some(symbol) => Some(stage67_register_prefix_point(store, symbol, log_t)?), + None => None, + }, + }) + }) + .collect::, RuntimePlanError>>()?; + + let mut evals = vec![Fr::from_u64(0); plan.stages.len()]; for (index, entry) in entries.iter().enumerate() { let eq = indexed_boolean_eq(index, r_address); - let values = stage67_bytecode_entry_stage_values( - entry, - num_lookup_tables, - stage4_register_point, - stage5_register_point, - &stage1_gamma_powers, - &stage2_gamma_powers, - &stage3_gamma_powers, - &stage4_gamma_powers, - &stage5_gamma_powers, - symbols, - )?; + let values = stage67_bytecode_entry_stage_values(plan, entry, &stage_contexts)?; for stage in 0..evals.len() { evals[stage] += eq * values[stage]; } @@ -271,87 +321,147 @@ fn stage67_bytecode_stage_value_evals( Ok(evals) } +struct Stage67BytecodeStageContext<'a> { + plan: &'a Stage67BytecodeStagePlan, + gamma_powers: Vec, + register_point: Option<&'a [Fr]>, +} + fn stage67_bytecode_entry_stage_values( + plan: &Stage67BytecodeReadRafPlan, entry: &E, - num_lookup_tables: usize, - stage4_register_point: &[Fr], - stage5_register_point: &[Fr], - stage1_gamma_powers: &[Fr], - stage2_gamma_powers: &[Fr], - stage3_gamma_powers: &[Fr], - stage4_gamma_powers: &[Fr], - stage5_gamma_powers: &[Fr], - symbols: &Stage67BytecodeSymbols, -) -> Result<[Fr; 5], RuntimePlanError> { - let flags = entry.circuit_flags(); - let mut stage1 = entry.address() + entry.imm() * stage1_gamma_powers[1]; - for (flag, gamma) in flags.iter().zip(stage1_gamma_powers.iter().skip(2)) { - if *flag { - stage1 += *gamma; - } - } + stage_contexts: &[Stage67BytecodeStageContext<'_>], +) -> Result, RuntimePlanError> { + stage_contexts + .iter() + .map(|context| stage67_bytecode_entry_stage_value(plan, entry, context)) + .collect() +} - let mut stage2 = Fr::from_u64(0); - if flags[5] { - stage2 += stage2_gamma_powers[0]; - } - if entry.is_branch() { - stage2 += stage2_gamma_powers[1]; - } - if flags[6] { - stage2 += stage2_gamma_powers[2]; - } - if flags[7] { - stage2 += stage2_gamma_powers[3]; +fn stage67_bytecode_entry_stage_value( + plan: &Stage67BytecodeReadRafPlan, + entry: &E, + context: &Stage67BytecodeStageContext<'_>, +) -> Result { + let mut value = Fr::from_u64(0); + for term in context.plan.terms { + value += match *term { + Stage67BytecodeTermPlan::Address { gamma_power } => { + entry.address() * context.gamma_powers[gamma_power] + } + Stage67BytecodeTermPlan::Imm { gamma_power } => { + entry.imm() * context.gamma_powers[gamma_power] + } + Stage67BytecodeTermPlan::CircuitFlag { index, gamma_power } => { + if entry.circuit_flags()[index] { + context.gamma_powers[gamma_power] + } else { + Fr::from_u64(0) + } + } + Stage67BytecodeTermPlan::EntryFlag { + flag, + expected, + gamma_power, + } => { + if stage67_bytecode_entry_flag(entry, flag) == expected { + context.gamma_powers[gamma_power] + } else { + Fr::from_u64(0) + } + } + Stage67BytecodeTermPlan::RegisterEq { + register, + gamma_power, + } => { + let register_point = + context + .register_point + .ok_or(RuntimePlanError::MissingValue { + symbol: context.plan.cycle_point, + })?; + stage67_register_eq( + stage67_bytecode_entry_register(entry, register), + register_point, + stage67_bytecode_register_symbol(plan, register), + )? * context.gamma_powers[gamma_power] + } + Stage67BytecodeTermPlan::LookupTable { gamma_base } => { + let Some(table) = entry.lookup_table() else { + continue; + }; + if table >= plan_lookup_table_count(context, gamma_base) { + return Err(RuntimePlanError::InvalidInputLength { + input: plan.entry_lookup_table, + expected: plan_lookup_table_count(context, gamma_base), + actual: table + 1, + }); + } + context.gamma_powers[gamma_base + table] + } + }; } + Ok(value) +} - let mut stage3 = entry.imm() + entry.address() * stage3_gamma_powers[1]; - if entry.left_is_rs1() { - stage3 += stage3_gamma_powers[2]; - } - if entry.left_is_pc() { - stage3 += stage3_gamma_powers[3]; - } - if entry.right_is_rs2() { - stage3 += stage3_gamma_powers[4]; - } - if entry.right_is_imm() { - stage3 += stage3_gamma_powers[5]; - } - if entry.is_noop() { - stage3 += stage3_gamma_powers[6]; - } - if flags[7] { - stage3 += stage3_gamma_powers[7]; - } - if flags[12] { - stage3 += stage3_gamma_powers[8]; - } +fn stage67_bytecode_stage_gamma_power_count( + stage: &Stage67BytecodeStagePlan, + num_lookup_tables: usize, +) -> usize { + stage + .terms + .iter() + .map(|term| match *term { + Stage67BytecodeTermPlan::Address { gamma_power } + | Stage67BytecodeTermPlan::Imm { gamma_power } + | Stage67BytecodeTermPlan::CircuitFlag { gamma_power, .. } + | Stage67BytecodeTermPlan::EntryFlag { gamma_power, .. } + | Stage67BytecodeTermPlan::RegisterEq { gamma_power, .. } => gamma_power + 1, + Stage67BytecodeTermPlan::LookupTable { gamma_base } => gamma_base + num_lookup_tables, + }) + .max() + .unwrap_or(0) +} + +fn plan_lookup_table_count(context: &Stage67BytecodeStageContext<'_>, gamma_base: usize) -> usize { + context.gamma_powers.len().saturating_sub(gamma_base) +} - let stage4 = stage67_register_eq(entry.rd(), stage4_register_point, symbols.entry_rd)? - * stage4_gamma_powers[0] - + stage67_register_eq(entry.rs1(), stage4_register_point, symbols.entry_rs1)? - * stage4_gamma_powers[1] - + stage67_register_eq(entry.rs2(), stage4_register_point, symbols.entry_rs2)? - * stage4_gamma_powers[2]; - - let mut stage5 = stage67_register_eq(entry.rd(), stage5_register_point, symbols.entry_rd)? - * stage5_gamma_powers[0]; - if !entry.is_interleaved() { - stage5 += stage5_gamma_powers[1]; +fn stage67_bytecode_entry_flag( + entry: &E, + flag: Stage67BytecodeFlag, +) -> bool { + match flag { + Stage67BytecodeFlag::IsInterleaved => entry.is_interleaved(), + Stage67BytecodeFlag::IsBranch => entry.is_branch(), + Stage67BytecodeFlag::LeftIsRs1 => entry.left_is_rs1(), + Stage67BytecodeFlag::LeftIsPc => entry.left_is_pc(), + Stage67BytecodeFlag::RightIsRs2 => entry.right_is_rs2(), + Stage67BytecodeFlag::RightIsImm => entry.right_is_imm(), + Stage67BytecodeFlag::IsNoop => entry.is_noop(), } - if let Some(table) = entry.lookup_table() { - if table >= num_lookup_tables { - return Err(RuntimePlanError::InvalidInputLength { - input: symbols.entry_lookup_table, - expected: num_lookup_tables, - actual: table + 1, - }); - } - stage5 += stage5_gamma_powers[2 + table]; +} + +fn stage67_bytecode_entry_register( + entry: &E, + register: Stage67BytecodeRegister, +) -> Option { + match register { + Stage67BytecodeRegister::Rd => entry.rd(), + Stage67BytecodeRegister::Rs1 => entry.rs1(), + Stage67BytecodeRegister::Rs2 => entry.rs2(), } +} - Ok([stage1, stage2, stage3, stage4, stage5]) +fn stage67_bytecode_register_symbol( + plan: &Stage67BytecodeReadRafPlan, + register: Stage67BytecodeRegister, +) -> &'static str { + match register { + Stage67BytecodeRegister::Rd => plan.registers.rd, + Stage67BytecodeRegister::Rs1 => plan.registers.rs1, + Stage67BytecodeRegister::Rs2 => plan.registers.rs2, + } } fn stage67_register_eq( diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index b00fb0c4a0..4b038614bb 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; -use super::jolt_relations::{expected_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeSymbols, Stage67RelationSymbols}; +use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeEntryContributionPlan, Stage67BytecodeFlag, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -99,31 +99,72 @@ const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { hamming_booleanity_instance: "stage6.hamming_booleanity.instance", }; -const STAGE6_BYTECODE_SYMBOLS: Stage67BytecodeSymbols = Stage67BytecodeSymbols { +const STAGE6_BYTECODE_STAGE1_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::Address { gamma_power: 0 }, + Stage67BytecodeTermPlan::Imm { gamma_power: 1 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 0, gamma_power: 2 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 1, gamma_power: 3 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 2, gamma_power: 4 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 3, gamma_power: 5 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 4, gamma_power: 6 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 7 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 8 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 9 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 8, gamma_power: 10 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 9, gamma_power: 11 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 10, gamma_power: 12 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 11, gamma_power: 13 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 14 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 13, gamma_power: 15 }, +]; +const STAGE6_BYTECODE_STAGE2_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 0 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsBranch, expected: true, gamma_power: 1 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 2 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 3 }, +]; +const STAGE6_BYTECODE_STAGE3_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::Imm { gamma_power: 0 }, + Stage67BytecodeTermPlan::Address { gamma_power: 1 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsRs1, expected: true, gamma_power: 2 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsPc, expected: true, gamma_power: 3 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsRs2, expected: true, gamma_power: 4 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsImm, expected: true, gamma_power: 5 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsNoop, expected: true, gamma_power: 6 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 7 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 8 }, +]; +const STAGE6_BYTECODE_STAGE4_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 }, + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs1, gamma_power: 1 }, + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs2, gamma_power: 2 }, +]; +const STAGE6_BYTECODE_STAGE5_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsInterleaved, expected: false, gamma_power: 1 }, + Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }, +]; +const STAGE6_BYTECODE_STAGES: &[Stage67BytecodeStagePlan] = &[ + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage1_gamma", cycle_point: "stage6.input.stage1.Imm", register_point: None, output_gamma_power: 0, identity_gamma_power: Some(5), terms: STAGE6_BYTECODE_STAGE1_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage2_gamma", cycle_point: "stage6.input.stage2.OpFlagJump", register_point: None, output_gamma_power: 1, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE2_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage3_gamma", cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC", register_point: None, output_gamma_power: 2, identity_gamma_power: Some(4), terms: STAGE6_BYTECODE_STAGE3_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage4_gamma", cycle_point: "stage6.input.stage4.Rs1Ra", register_point: Some("stage6.input.stage4.Rs1Ra"), output_gamma_power: 3, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE4_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage5_gamma", cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa", register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"), output_gamma_power: 4, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE5_TERMS }, +]; + +const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { point: "stage6.bytecode_read_raf.point", gamma: "stage6.bytecode_read_raf.gamma", bytecode_ra_eval_prefix: "stage6.bytecode_read_raf.eval.BytecodeRa_", entries: "stage6.bytecode_read_raf.entries", entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", - stage_gammas: [ - "stage6.bytecode_read_raf.stage1_gamma", - "stage6.bytecode_read_raf.stage2_gamma", - "stage6.bytecode_read_raf.stage3_gamma", - "stage6.bytecode_read_raf.stage4_gamma", - "stage6.bytecode_read_raf.stage5_gamma", - ], - stage_cycle_points: [ - "stage6.input.stage1.Imm", - "stage6.input.stage2.OpFlagJump", - "stage6.input.stage3.spartan_shift.UnexpandedPC", - "stage6.input.stage4.Rs1Ra", - "stage6.input.stage5.registers_val_evaluation.RdWa", - ], - stage4_register_point: "stage6.input.stage4.Rs1Ra", - stage5_register_point: "stage6.input.stage5.registers_val_evaluation.RdWa", - entry_rd: "stage6.bytecode.entry.rd", - entry_rs1: "stage6.bytecode.entry.rs1", - entry_rs2: "stage6.bytecode.entry.rs2", + stages: STAGE6_BYTECODE_STAGES, + entry_contribution: Stage67BytecodeEntryContributionPlan { gamma_power: 7 }, + registers: Stage67BytecodeRegisterSymbols { + rd: "stage6.bytecode.entry.rd", + rs1: "stage6.bytecode.entry.rs1", + rs2: "stage6.bytecode.entry.rs2", + }, entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; @@ -1113,7 +1154,8 @@ fn expected_bytecode_read_raf( local_point: &[Fr], ) -> Result { let log_t = stage6_trace_rounds(program)?; - Ok(expected_stage67_bytecode_read_raf( + Ok(evaluate_stage67_bytecode_read_raf( + &STAGE6_BYTECODE_PLAN, &data.entries, data.entry_bytecode_index, data.num_lookup_tables, @@ -1121,7 +1163,6 @@ fn expected_bytecode_read_raf( evals, local_point, log_t, - &STAGE6_BYTECODE_SYMBOLS, )?) } From 9b405ab7ac5383f1f64cdfb4acf1faa01919a758 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 20:57:31 -0600 Subject: [PATCH 041/171] refactor(bolt): plan stage6 bytecode rows Move Stage 6 bytecode read-RAF constants into typed verifier planning data and render them mechanically from the Stage 6 Rust emitter. The generated verifier artifact remains unchanged; this sets up future verifier-planning passes without changing proof serialization. --- .../src/protocols/jolt/emit/rust/stage6.rs | 228 +++++++---- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../bolt/src/protocols/jolt/verifier_plan.rs | 381 ++++++++++++++++++ 3 files changed, 540 insertions(+), 70 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_plan.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index a0e3f598ca..f01ca4b956 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -22,6 +22,10 @@ use super::output_claims::{ }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::verifier_plan::{ + stage6_bytecode_read_raf_plan, BytecodeFlag, BytecodeReadRafPlan, BytecodeReadRafTermPlan, + BytecodeRegister, +}; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] @@ -1460,76 +1464,13 @@ pub struct Stage6VerifierData { const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { hamming_booleanity_instance: "stage6.hamming_booleanity.instance", }; - -const STAGE6_BYTECODE_STAGE1_TERMS: &[Stage67BytecodeTermPlan] = &[ - Stage67BytecodeTermPlan::Address { gamma_power: 0 }, - Stage67BytecodeTermPlan::Imm { gamma_power: 1 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 0, gamma_power: 2 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 1, gamma_power: 3 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 2, gamma_power: 4 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 3, gamma_power: 5 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 4, gamma_power: 6 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 7 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 8 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 9 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 8, gamma_power: 10 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 9, gamma_power: 11 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 10, gamma_power: 12 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 11, gamma_power: 13 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 14 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 13, gamma_power: 15 }, -]; -const STAGE6_BYTECODE_STAGE2_TERMS: &[Stage67BytecodeTermPlan] = &[ - Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 0 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsBranch, expected: true, gamma_power: 1 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 2 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 3 }, -]; -const STAGE6_BYTECODE_STAGE3_TERMS: &[Stage67BytecodeTermPlan] = &[ - Stage67BytecodeTermPlan::Imm { gamma_power: 0 }, - Stage67BytecodeTermPlan::Address { gamma_power: 1 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsRs1, expected: true, gamma_power: 2 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsPc, expected: true, gamma_power: 3 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsRs2, expected: true, gamma_power: 4 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsImm, expected: true, gamma_power: 5 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsNoop, expected: true, gamma_power: 6 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 7 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 8 }, -]; -const STAGE6_BYTECODE_STAGE4_TERMS: &[Stage67BytecodeTermPlan] = &[ - Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 }, - Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs1, gamma_power: 1 }, - Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs2, gamma_power: 2 }, -]; -const STAGE6_BYTECODE_STAGE5_TERMS: &[Stage67BytecodeTermPlan] = &[ - Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsInterleaved, expected: false, gamma_power: 1 }, - Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }, -]; -const STAGE6_BYTECODE_STAGES: &[Stage67BytecodeStagePlan] = &[ - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage1_gamma", cycle_point: "stage6.input.stage1.Imm", register_point: None, output_gamma_power: 0, identity_gamma_power: Some(5), terms: STAGE6_BYTECODE_STAGE1_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage2_gamma", cycle_point: "stage6.input.stage2.OpFlagJump", register_point: None, output_gamma_power: 1, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE2_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage3_gamma", cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC", register_point: None, output_gamma_power: 2, identity_gamma_power: Some(4), terms: STAGE6_BYTECODE_STAGE3_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage4_gamma", cycle_point: "stage6.input.stage4.Rs1Ra", register_point: Some("stage6.input.stage4.Rs1Ra"), output_gamma_power: 3, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE4_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage5_gamma", cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa", register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"), output_gamma_power: 4, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE5_TERMS }, -]; - -const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { - point: "stage6.bytecode_read_raf.point", - gamma: "stage6.bytecode_read_raf.gamma", - bytecode_ra_eval_prefix: "stage6.bytecode_read_raf.eval.BytecodeRa_", - entries: "stage6.bytecode_read_raf.entries", - entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", - stages: STAGE6_BYTECODE_STAGES, - entry_contribution: Stage67BytecodeEntryContributionPlan { gamma_power: 7 }, - registers: Stage67BytecodeRegisterSymbols { - rd: "stage6.bytecode.entry.rd", - rs1: "stage6.bytecode.entry.rs1", - rs2: "stage6.bytecode.entry.rs2", - }, - entry_lookup_table: "stage6.bytecode.entry.lookup_table", -}; - +"#, + ); + source.push_str(&emit_stage6_bytecode_read_raf_plan( + stage6_bytecode_read_raf_plan(), + )); + source.push_str( + r#" #[derive(Debug)] pub enum VerifyStage6Error { UnexpectedProofCount { expected: usize, got: usize }, @@ -2726,6 +2667,153 @@ fn intern_str_array( name } +fn emit_stage6_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { + let mut source = "\n".to_owned(); + + for stage in plan.stages { + push_format( + &mut source, + format_args!( + "const {}: &[Stage67BytecodeTermPlan] = &[\n", + stage.terms_const + ), + ); + for term in stage.terms { + push_format( + &mut source, + format_args!(" {},\n", emit_stage6_bytecode_term_plan(term)), + ); + } + source.push_str("];\n"); + } + + push_format( + &mut source, + format_args!( + "const {}: &[Stage67BytecodeStagePlan] = &[\n", + plan.stages_const + ), + ); + for stage in plan.stages { + push_format( + &mut source, + format_args!( + " Stage67BytecodeStagePlan {{ gamma: {}, cycle_point: {}, register_point: {}, output_gamma_power: {}, identity_gamma_power: {}, terms: {} }},\n", + rust_str(stage.gamma), + rust_str(stage.cycle_point), + rust_option_str(stage.register_point), + stage.output_gamma_power, + emit_option_usize(stage.identity_gamma_power), + stage.terms_const, + ), + ); + } + source.push_str("];\n\n"); + + push_format( + &mut source, + format_args!( + "const {}: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan {{\n", + plan.const_name + ), + ); + push_format( + &mut source, + format_args!( + " point: {},\n gamma: {},\n bytecode_ra_eval_prefix: {},\n entries: {},\n entry_bytecode_index: {},\n stages: {},\n", + rust_str(plan.point), + rust_str(plan.gamma), + rust_str(plan.bytecode_ra_eval_prefix), + rust_str(plan.entries), + rust_str(plan.entry_bytecode_index), + plan.stages_const, + ), + ); + push_format( + &mut source, + format_args!( + " entry_contribution: Stage67BytecodeEntryContributionPlan {{ gamma_power: {} }},\n", + plan.entry_contribution.gamma_power + ), + ); + source.push_str(" registers: Stage67BytecodeRegisterSymbols {\n"); + push_format( + &mut source, + format_args!( + " rd: {},\n rs1: {},\n rs2: {},\n", + rust_str(plan.registers.rd), + rust_str(plan.registers.rs1), + rust_str(plan.registers.rs2), + ), + ); + source.push_str(" },\n"); + push_format( + &mut source, + format_args!( + " entry_lookup_table: {},\n", + rust_str(plan.entry_lookup_table) + ), + ); + source.push_str("};\n"); + source +} + +fn emit_stage6_bytecode_term_plan(term: &BytecodeReadRafTermPlan) -> String { + match term { + BytecodeReadRafTermPlan::Address { gamma_power } => { + format!("Stage67BytecodeTermPlan::Address {{ gamma_power: {gamma_power} }}") + } + BytecodeReadRafTermPlan::Imm { gamma_power } => { + format!("Stage67BytecodeTermPlan::Imm {{ gamma_power: {gamma_power} }}") + } + BytecodeReadRafTermPlan::CircuitFlag { index, gamma_power } => format!( + "Stage67BytecodeTermPlan::CircuitFlag {{ index: {index}, gamma_power: {gamma_power} }}" + ), + BytecodeReadRafTermPlan::EntryFlag { + flag, + expected, + gamma_power, + } => format!( + "Stage67BytecodeTermPlan::EntryFlag {{ flag: {}, expected: {expected}, gamma_power: {gamma_power} }}", + emit_stage6_bytecode_flag(*flag) + ), + BytecodeReadRafTermPlan::RegisterEq { + register, + gamma_power, + } => format!( + "Stage67BytecodeTermPlan::RegisterEq {{ register: {}, gamma_power: {gamma_power} }}", + emit_stage6_bytecode_register(*register) + ), + BytecodeReadRafTermPlan::LookupTable { gamma_base } => { + format!("Stage67BytecodeTermPlan::LookupTable {{ gamma_base: {gamma_base} }}") + } + } +} + +fn emit_stage6_bytecode_flag(flag: BytecodeFlag) -> &'static str { + match flag { + BytecodeFlag::IsInterleaved => "Stage67BytecodeFlag::IsInterleaved", + BytecodeFlag::IsBranch => "Stage67BytecodeFlag::IsBranch", + BytecodeFlag::LeftIsRs1 => "Stage67BytecodeFlag::LeftIsRs1", + BytecodeFlag::LeftIsPc => "Stage67BytecodeFlag::LeftIsPc", + BytecodeFlag::RightIsRs2 => "Stage67BytecodeFlag::RightIsRs2", + BytecodeFlag::RightIsImm => "Stage67BytecodeFlag::RightIsImm", + BytecodeFlag::IsNoop => "Stage67BytecodeFlag::IsNoop", + } +} + +fn emit_stage6_bytecode_register(register: BytecodeRegister) -> &'static str { + match register { + BytecodeRegister::Rd => "Stage67BytecodeRegister::Rd", + BytecodeRegister::Rs1 => "Stage67BytecodeRegister::Rs1", + BytecodeRegister::Rs2 => "Stage67BytecodeRegister::Rs2", + } +} + +fn emit_option_usize(value: Option) -> String { + value.map_or_else(|| "None".to_owned(), |value| format!("Some({value})")) +} + fn rust_str(value: &str) -> String { format!("{value:?}") } diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index 91da996a0e..15905a4956 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -4,6 +4,7 @@ pub mod oracles; pub mod params; pub mod phases; pub mod validate; +pub(crate) mod verifier_plan; pub use artifacts::{ assemble_jolt_generated_crates, assemble_jolt_workspace_generated_crates, jolt_artifact_config, diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs new file mode 100644 index 0000000000..d22a362b35 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -0,0 +1,381 @@ +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct BytecodeReadRafPlan { + pub(crate) const_name: &'static str, + pub(crate) point: &'static str, + pub(crate) gamma: &'static str, + pub(crate) bytecode_ra_eval_prefix: &'static str, + pub(crate) entries: &'static str, + pub(crate) entry_bytecode_index: &'static str, + pub(crate) stages_const: &'static str, + pub(crate) stages: &'static [BytecodeReadRafStagePlan], + pub(crate) entry_contribution: BytecodeEntryContributionPlan, + pub(crate) registers: BytecodeRegisterSymbols, + pub(crate) entry_lookup_table: &'static str, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct BytecodeReadRafStagePlan { + pub(crate) terms_const: &'static str, + pub(crate) gamma: &'static str, + pub(crate) cycle_point: &'static str, + pub(crate) register_point: Option<&'static str>, + pub(crate) output_gamma_power: usize, + pub(crate) identity_gamma_power: Option, + pub(crate) terms: &'static [BytecodeReadRafTermPlan], +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct BytecodeEntryContributionPlan { + pub(crate) gamma_power: usize, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) struct BytecodeRegisterSymbols { + pub(crate) rd: &'static str, + pub(crate) rs1: &'static str, + pub(crate) rs2: &'static str, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum BytecodeReadRafTermPlan { + Address { + gamma_power: usize, + }, + Imm { + gamma_power: usize, + }, + CircuitFlag { + index: usize, + gamma_power: usize, + }, + EntryFlag { + flag: BytecodeFlag, + expected: bool, + gamma_power: usize, + }, + RegisterEq { + register: BytecodeRegister, + gamma_power: usize, + }, + LookupTable { + gamma_base: usize, + }, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum BytecodeFlag { + IsInterleaved, + IsBranch, + LeftIsRs1, + LeftIsPc, + RightIsRs2, + RightIsImm, + IsNoop, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum BytecodeRegister { + Rd, + Rs1, + Rs2, +} + +const STAGE6_BYTECODE_STAGE1_TERMS: &[BytecodeReadRafTermPlan] = &[ + BytecodeReadRafTermPlan::Address { gamma_power: 0 }, + BytecodeReadRafTermPlan::Imm { gamma_power: 1 }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 0, + gamma_power: 2, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 1, + gamma_power: 3, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 2, + gamma_power: 4, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 3, + gamma_power: 5, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 4, + gamma_power: 6, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 5, + gamma_power: 7, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 6, + gamma_power: 8, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 7, + gamma_power: 9, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 8, + gamma_power: 10, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 9, + gamma_power: 11, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 10, + gamma_power: 12, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 11, + gamma_power: 13, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 12, + gamma_power: 14, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 13, + gamma_power: 15, + }, +]; + +const STAGE6_BYTECODE_STAGE2_TERMS: &[BytecodeReadRafTermPlan] = &[ + BytecodeReadRafTermPlan::CircuitFlag { + index: 5, + gamma_power: 0, + }, + BytecodeReadRafTermPlan::EntryFlag { + flag: BytecodeFlag::IsBranch, + expected: true, + gamma_power: 1, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 6, + gamma_power: 2, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 7, + gamma_power: 3, + }, +]; + +const STAGE6_BYTECODE_STAGE3_TERMS: &[BytecodeReadRafTermPlan] = &[ + BytecodeReadRafTermPlan::Imm { gamma_power: 0 }, + BytecodeReadRafTermPlan::Address { gamma_power: 1 }, + BytecodeReadRafTermPlan::EntryFlag { + flag: BytecodeFlag::LeftIsRs1, + expected: true, + gamma_power: 2, + }, + BytecodeReadRafTermPlan::EntryFlag { + flag: BytecodeFlag::LeftIsPc, + expected: true, + gamma_power: 3, + }, + BytecodeReadRafTermPlan::EntryFlag { + flag: BytecodeFlag::RightIsRs2, + expected: true, + gamma_power: 4, + }, + BytecodeReadRafTermPlan::EntryFlag { + flag: BytecodeFlag::RightIsImm, + expected: true, + gamma_power: 5, + }, + BytecodeReadRafTermPlan::EntryFlag { + flag: BytecodeFlag::IsNoop, + expected: true, + gamma_power: 6, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 7, + gamma_power: 7, + }, + BytecodeReadRafTermPlan::CircuitFlag { + index: 12, + gamma_power: 8, + }, +]; + +const STAGE6_BYTECODE_STAGE4_TERMS: &[BytecodeReadRafTermPlan] = &[ + BytecodeReadRafTermPlan::RegisterEq { + register: BytecodeRegister::Rd, + gamma_power: 0, + }, + BytecodeReadRafTermPlan::RegisterEq { + register: BytecodeRegister::Rs1, + gamma_power: 1, + }, + BytecodeReadRafTermPlan::RegisterEq { + register: BytecodeRegister::Rs2, + gamma_power: 2, + }, +]; + +const STAGE6_BYTECODE_STAGE5_TERMS: &[BytecodeReadRafTermPlan] = &[ + BytecodeReadRafTermPlan::RegisterEq { + register: BytecodeRegister::Rd, + gamma_power: 0, + }, + BytecodeReadRafTermPlan::EntryFlag { + flag: BytecodeFlag::IsInterleaved, + expected: false, + gamma_power: 1, + }, + BytecodeReadRafTermPlan::LookupTable { gamma_base: 2 }, +]; + +const STAGE6_BYTECODE_STAGES: &[BytecodeReadRafStagePlan] = &[ + BytecodeReadRafStagePlan { + terms_const: "STAGE6_BYTECODE_STAGE1_TERMS", + gamma: "stage6.bytecode_read_raf.stage1_gamma", + cycle_point: "stage6.input.stage1.Imm", + register_point: None, + output_gamma_power: 0, + identity_gamma_power: Some(5), + terms: STAGE6_BYTECODE_STAGE1_TERMS, + }, + BytecodeReadRafStagePlan { + terms_const: "STAGE6_BYTECODE_STAGE2_TERMS", + gamma: "stage6.bytecode_read_raf.stage2_gamma", + cycle_point: "stage6.input.stage2.OpFlagJump", + register_point: None, + output_gamma_power: 1, + identity_gamma_power: None, + terms: STAGE6_BYTECODE_STAGE2_TERMS, + }, + BytecodeReadRafStagePlan { + terms_const: "STAGE6_BYTECODE_STAGE3_TERMS", + gamma: "stage6.bytecode_read_raf.stage3_gamma", + cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC", + register_point: None, + output_gamma_power: 2, + identity_gamma_power: Some(4), + terms: STAGE6_BYTECODE_STAGE3_TERMS, + }, + BytecodeReadRafStagePlan { + terms_const: "STAGE6_BYTECODE_STAGE4_TERMS", + gamma: "stage6.bytecode_read_raf.stage4_gamma", + cycle_point: "stage6.input.stage4.Rs1Ra", + register_point: Some("stage6.input.stage4.Rs1Ra"), + output_gamma_power: 3, + identity_gamma_power: None, + terms: STAGE6_BYTECODE_STAGE4_TERMS, + }, + BytecodeReadRafStagePlan { + terms_const: "STAGE6_BYTECODE_STAGE5_TERMS", + gamma: "stage6.bytecode_read_raf.stage5_gamma", + cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa", + register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"), + output_gamma_power: 4, + identity_gamma_power: None, + terms: STAGE6_BYTECODE_STAGE5_TERMS, + }, +]; + +pub(crate) const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { + const_name: "STAGE6_BYTECODE_PLAN", + point: "stage6.bytecode_read_raf.point", + gamma: "stage6.bytecode_read_raf.gamma", + bytecode_ra_eval_prefix: "stage6.bytecode_read_raf.eval.BytecodeRa_", + entries: "stage6.bytecode_read_raf.entries", + entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", + stages_const: "STAGE6_BYTECODE_STAGES", + stages: STAGE6_BYTECODE_STAGES, + entry_contribution: BytecodeEntryContributionPlan { gamma_power: 7 }, + registers: BytecodeRegisterSymbols { + rd: "stage6.bytecode.entry.rd", + rs1: "stage6.bytecode.entry.rs1", + rs2: "stage6.bytecode.entry.rs2", + }, + entry_lookup_table: "stage6.bytecode.entry.lookup_table", +}; + +pub(crate) fn stage6_bytecode_read_raf_plan() -> &'static BytecodeReadRafPlan { + &STAGE6_BYTECODE_READ_RAF_PLAN +} + +#[cfg(test)] +mod tests { + use super::{ + stage6_bytecode_read_raf_plan, BytecodeFlag, BytecodeReadRafTermPlan, BytecodeRegister, + }; + + #[test] + fn stage6_bytecode_plan_rows_encode_the_read_raf_reduction() { + let plan = stage6_bytecode_read_raf_plan(); + + assert_eq!(plan.stages.len(), 5); + assert_eq!(plan.entry_contribution.gamma_power, 7); + assert_eq!(plan.registers.rd, "stage6.bytecode.entry.rd"); + assert_eq!( + plan.entry_lookup_table, + "stage6.bytecode.entry.lookup_table" + ); + + let stage1 = &plan.stages[0]; + assert_eq!(stage1.output_gamma_power, 0); + assert_eq!(stage1.identity_gamma_power, Some(5)); + assert_eq!(stage1.terms.len(), 16); + assert_eq!( + stage1.terms[0], + BytecodeReadRafTermPlan::Address { gamma_power: 0 } + ); + assert_eq!( + stage1.terms[1], + BytecodeReadRafTermPlan::Imm { gamma_power: 1 } + ); + for (index, term) in stage1.terms[2..].iter().enumerate() { + assert_eq!( + *term, + BytecodeReadRafTermPlan::CircuitFlag { + index, + gamma_power: index + 2, + } + ); + } + + assert_eq!( + plan.stages[1].terms[1], + BytecodeReadRafTermPlan::EntryFlag { + flag: BytecodeFlag::IsBranch, + expected: true, + gamma_power: 1, + } + ); + assert_eq!( + plan.stages[3].terms, + &[ + BytecodeReadRafTermPlan::RegisterEq { + register: BytecodeRegister::Rd, + gamma_power: 0, + }, + BytecodeReadRafTermPlan::RegisterEq { + register: BytecodeRegister::Rs1, + gamma_power: 1, + }, + BytecodeReadRafTermPlan::RegisterEq { + register: BytecodeRegister::Rs2, + gamma_power: 2, + }, + ] + ); + assert_eq!( + plan.stages[4].terms, + &[ + BytecodeReadRafTermPlan::RegisterEq { + register: BytecodeRegister::Rd, + gamma_power: 0, + }, + BytecodeReadRafTermPlan::EntryFlag { + flag: BytecodeFlag::IsInterleaved, + expected: false, + gamma_power: 1, + }, + BytecodeReadRafTermPlan::LookupTable { gamma_base: 2 }, + ] + ); + } +} From 4228ed641ef0c168dda65d48b4a44ab755939cfd Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 21:02:38 -0600 Subject: [PATCH 042/171] refactor(bolt): narrow bytecode plan module name Rename the Stage 6 bytecode read-RAF planning module away from the overbroad verifier_plan name. This keeps the new planning seam honest: it contains only Stage 6 bytecode read-RAF plan data, not the verifier planning layer as a whole. --- crates/bolt/src/protocols/jolt/emit/rust/stage6.rs | 2 +- crates/bolt/src/protocols/jolt/mod.rs | 2 +- .../jolt/{verifier_plan.rs => stage6_bytecode_read_raf_plan.rs} | 0 3 files changed, 2 insertions(+), 2 deletions(-) rename crates/bolt/src/protocols/jolt/{verifier_plan.rs => stage6_bytecode_read_raf_plan.rs} (100%) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index f01ca4b956..4a1bc600e1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -22,7 +22,7 @@ use super::output_claims::{ }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::verifier_plan::{ +use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ stage6_bytecode_read_raf_plan, BytecodeFlag, BytecodeReadRafPlan, BytecodeReadRafTermPlan, BytecodeRegister, }; diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index 15905a4956..14141f2ecf 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -3,8 +3,8 @@ pub mod emit; pub mod oracles; pub mod params; pub mod phases; +pub(crate) mod stage6_bytecode_read_raf_plan; pub mod validate; -pub(crate) mod verifier_plan; pub use artifacts::{ assemble_jolt_generated_crates, assemble_jolt_workspace_generated_crates, jolt_artifact_config, diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs similarity index 100% rename from crates/bolt/src/protocols/jolt/verifier_plan.rs rename to crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs From 155f4487d0484e6a3ac114682ac837026b91b729 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 21:13:17 -0600 Subject: [PATCH 043/171] refactor(bolt): move bytecode plan renderer Move Stage 6 bytecode read-RAF Rust constant rendering into the narrowly named plan module. This leaves the Stage 6 emitter responsible only for splicing the rendered constants and keeps generated verifier output unchanged. --- .../src/protocols/jolt/emit/rust/stage6.rs | 156 +-------------- .../jolt/stage6_bytecode_read_raf_plan.rs | 182 +++++++++++++++++- 2 files changed, 179 insertions(+), 159 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 4a1bc600e1..f3f9855f26 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -22,10 +22,7 @@ use super::output_claims::{ }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ - stage6_bytecode_read_raf_plan, BytecodeFlag, BytecodeReadRafPlan, BytecodeReadRafTermPlan, - BytecodeRegister, -}; +use crate::protocols::jolt::stage6_bytecode_read_raf_plan::emit_stage6_bytecode_read_raf_plan_constants; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] @@ -1466,9 +1463,7 @@ const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { }; "#, ); - source.push_str(&emit_stage6_bytecode_read_raf_plan( - stage6_bytecode_read_raf_plan(), - )); + source.push_str(&emit_stage6_bytecode_read_raf_plan_constants()); source.push_str( r#" #[derive(Debug)] @@ -2667,153 +2662,6 @@ fn intern_str_array( name } -fn emit_stage6_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { - let mut source = "\n".to_owned(); - - for stage in plan.stages { - push_format( - &mut source, - format_args!( - "const {}: &[Stage67BytecodeTermPlan] = &[\n", - stage.terms_const - ), - ); - for term in stage.terms { - push_format( - &mut source, - format_args!(" {},\n", emit_stage6_bytecode_term_plan(term)), - ); - } - source.push_str("];\n"); - } - - push_format( - &mut source, - format_args!( - "const {}: &[Stage67BytecodeStagePlan] = &[\n", - plan.stages_const - ), - ); - for stage in plan.stages { - push_format( - &mut source, - format_args!( - " Stage67BytecodeStagePlan {{ gamma: {}, cycle_point: {}, register_point: {}, output_gamma_power: {}, identity_gamma_power: {}, terms: {} }},\n", - rust_str(stage.gamma), - rust_str(stage.cycle_point), - rust_option_str(stage.register_point), - stage.output_gamma_power, - emit_option_usize(stage.identity_gamma_power), - stage.terms_const, - ), - ); - } - source.push_str("];\n\n"); - - push_format( - &mut source, - format_args!( - "const {}: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan {{\n", - plan.const_name - ), - ); - push_format( - &mut source, - format_args!( - " point: {},\n gamma: {},\n bytecode_ra_eval_prefix: {},\n entries: {},\n entry_bytecode_index: {},\n stages: {},\n", - rust_str(plan.point), - rust_str(plan.gamma), - rust_str(plan.bytecode_ra_eval_prefix), - rust_str(plan.entries), - rust_str(plan.entry_bytecode_index), - plan.stages_const, - ), - ); - push_format( - &mut source, - format_args!( - " entry_contribution: Stage67BytecodeEntryContributionPlan {{ gamma_power: {} }},\n", - plan.entry_contribution.gamma_power - ), - ); - source.push_str(" registers: Stage67BytecodeRegisterSymbols {\n"); - push_format( - &mut source, - format_args!( - " rd: {},\n rs1: {},\n rs2: {},\n", - rust_str(plan.registers.rd), - rust_str(plan.registers.rs1), - rust_str(plan.registers.rs2), - ), - ); - source.push_str(" },\n"); - push_format( - &mut source, - format_args!( - " entry_lookup_table: {},\n", - rust_str(plan.entry_lookup_table) - ), - ); - source.push_str("};\n"); - source -} - -fn emit_stage6_bytecode_term_plan(term: &BytecodeReadRafTermPlan) -> String { - match term { - BytecodeReadRafTermPlan::Address { gamma_power } => { - format!("Stage67BytecodeTermPlan::Address {{ gamma_power: {gamma_power} }}") - } - BytecodeReadRafTermPlan::Imm { gamma_power } => { - format!("Stage67BytecodeTermPlan::Imm {{ gamma_power: {gamma_power} }}") - } - BytecodeReadRafTermPlan::CircuitFlag { index, gamma_power } => format!( - "Stage67BytecodeTermPlan::CircuitFlag {{ index: {index}, gamma_power: {gamma_power} }}" - ), - BytecodeReadRafTermPlan::EntryFlag { - flag, - expected, - gamma_power, - } => format!( - "Stage67BytecodeTermPlan::EntryFlag {{ flag: {}, expected: {expected}, gamma_power: {gamma_power} }}", - emit_stage6_bytecode_flag(*flag) - ), - BytecodeReadRafTermPlan::RegisterEq { - register, - gamma_power, - } => format!( - "Stage67BytecodeTermPlan::RegisterEq {{ register: {}, gamma_power: {gamma_power} }}", - emit_stage6_bytecode_register(*register) - ), - BytecodeReadRafTermPlan::LookupTable { gamma_base } => { - format!("Stage67BytecodeTermPlan::LookupTable {{ gamma_base: {gamma_base} }}") - } - } -} - -fn emit_stage6_bytecode_flag(flag: BytecodeFlag) -> &'static str { - match flag { - BytecodeFlag::IsInterleaved => "Stage67BytecodeFlag::IsInterleaved", - BytecodeFlag::IsBranch => "Stage67BytecodeFlag::IsBranch", - BytecodeFlag::LeftIsRs1 => "Stage67BytecodeFlag::LeftIsRs1", - BytecodeFlag::LeftIsPc => "Stage67BytecodeFlag::LeftIsPc", - BytecodeFlag::RightIsRs2 => "Stage67BytecodeFlag::RightIsRs2", - BytecodeFlag::RightIsImm => "Stage67BytecodeFlag::RightIsImm", - BytecodeFlag::IsNoop => "Stage67BytecodeFlag::IsNoop", - } -} - -fn emit_stage6_bytecode_register(register: BytecodeRegister) -> &'static str { - match register { - BytecodeRegister::Rd => "Stage67BytecodeRegister::Rd", - BytecodeRegister::Rs1 => "Stage67BytecodeRegister::Rs1", - BytecodeRegister::Rs2 => "Stage67BytecodeRegister::Rs2", - } -} - -fn emit_option_usize(value: Option) -> String { - value.map_or_else(|| "None".to_owned(), |value| format!("Some({value})")) -} - fn rust_str(value: &str) -> String { format!("{value:?}") } diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index d22a362b35..195439cf20 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -1,3 +1,5 @@ +use crate::emit::rust::push_format; + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) struct BytecodeReadRafPlan { pub(crate) const_name: &'static str, @@ -275,7 +277,7 @@ const STAGE6_BYTECODE_STAGES: &[BytecodeReadRafStagePlan] = &[ }, ]; -pub(crate) const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { +const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { const_name: "STAGE6_BYTECODE_PLAN", point: "stage6.bytecode_read_raf.point", gamma: "stage6.bytecode_read_raf.gamma", @@ -293,19 +295,178 @@ pub(crate) const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeRe entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; -pub(crate) fn stage6_bytecode_read_raf_plan() -> &'static BytecodeReadRafPlan { - &STAGE6_BYTECODE_READ_RAF_PLAN +pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants() -> String { + emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN) +} + +fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { + let mut source = "\n".to_owned(); + + for stage in plan.stages { + push_format( + &mut source, + format_args!( + "const {}: &[Stage67BytecodeTermPlan] = &[\n", + stage.terms_const + ), + ); + for term in stage.terms { + push_format( + &mut source, + format_args!(" {},\n", emit_bytecode_read_raf_term_plan(term)), + ); + } + source.push_str("];\n"); + } + + push_format( + &mut source, + format_args!( + "const {}: &[Stage67BytecodeStagePlan] = &[\n", + plan.stages_const + ), + ); + for stage in plan.stages { + push_format( + &mut source, + format_args!( + " Stage67BytecodeStagePlan {{ gamma: {}, cycle_point: {}, register_point: {}, output_gamma_power: {}, identity_gamma_power: {}, terms: {} }},\n", + rust_str(stage.gamma), + rust_str(stage.cycle_point), + rust_option_str(stage.register_point), + stage.output_gamma_power, + emit_option_usize(stage.identity_gamma_power), + stage.terms_const, + ), + ); + } + source.push_str("];\n\n"); + + push_format( + &mut source, + format_args!( + "const {}: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan {{\n", + plan.const_name + ), + ); + push_format( + &mut source, + format_args!( + " point: {},\n gamma: {},\n bytecode_ra_eval_prefix: {},\n entries: {},\n entry_bytecode_index: {},\n stages: {},\n", + rust_str(plan.point), + rust_str(plan.gamma), + rust_str(plan.bytecode_ra_eval_prefix), + rust_str(plan.entries), + rust_str(plan.entry_bytecode_index), + plan.stages_const, + ), + ); + push_format( + &mut source, + format_args!( + " entry_contribution: Stage67BytecodeEntryContributionPlan {{ gamma_power: {} }},\n", + plan.entry_contribution.gamma_power + ), + ); + source.push_str(" registers: Stage67BytecodeRegisterSymbols {\n"); + push_format( + &mut source, + format_args!( + " rd: {},\n rs1: {},\n rs2: {},\n", + rust_str(plan.registers.rd), + rust_str(plan.registers.rs1), + rust_str(plan.registers.rs2), + ), + ); + source.push_str(" },\n"); + push_format( + &mut source, + format_args!( + " entry_lookup_table: {},\n", + rust_str(plan.entry_lookup_table) + ), + ); + source.push_str("};\n"); + source +} + +fn emit_bytecode_read_raf_term_plan(term: &BytecodeReadRafTermPlan) -> String { + match term { + BytecodeReadRafTermPlan::Address { gamma_power } => { + format!("Stage67BytecodeTermPlan::Address {{ gamma_power: {gamma_power} }}") + } + BytecodeReadRafTermPlan::Imm { gamma_power } => { + format!("Stage67BytecodeTermPlan::Imm {{ gamma_power: {gamma_power} }}") + } + BytecodeReadRafTermPlan::CircuitFlag { index, gamma_power } => format!( + "Stage67BytecodeTermPlan::CircuitFlag {{ index: {index}, gamma_power: {gamma_power} }}" + ), + BytecodeReadRafTermPlan::EntryFlag { + flag, + expected, + gamma_power, + } => format!( + "Stage67BytecodeTermPlan::EntryFlag {{ flag: {}, expected: {expected}, gamma_power: {gamma_power} }}", + emit_bytecode_flag(*flag) + ), + BytecodeReadRafTermPlan::RegisterEq { + register, + gamma_power, + } => format!( + "Stage67BytecodeTermPlan::RegisterEq {{ register: {}, gamma_power: {gamma_power} }}", + emit_bytecode_register(*register) + ), + BytecodeReadRafTermPlan::LookupTable { gamma_base } => { + format!("Stage67BytecodeTermPlan::LookupTable {{ gamma_base: {gamma_base} }}") + } + } +} + +fn emit_bytecode_flag(flag: BytecodeFlag) -> &'static str { + match flag { + BytecodeFlag::IsInterleaved => "Stage67BytecodeFlag::IsInterleaved", + BytecodeFlag::IsBranch => "Stage67BytecodeFlag::IsBranch", + BytecodeFlag::LeftIsRs1 => "Stage67BytecodeFlag::LeftIsRs1", + BytecodeFlag::LeftIsPc => "Stage67BytecodeFlag::LeftIsPc", + BytecodeFlag::RightIsRs2 => "Stage67BytecodeFlag::RightIsRs2", + BytecodeFlag::RightIsImm => "Stage67BytecodeFlag::RightIsImm", + BytecodeFlag::IsNoop => "Stage67BytecodeFlag::IsNoop", + } +} + +fn emit_bytecode_register(register: BytecodeRegister) -> &'static str { + match register { + BytecodeRegister::Rd => "Stage67BytecodeRegister::Rd", + BytecodeRegister::Rs1 => "Stage67BytecodeRegister::Rs1", + BytecodeRegister::Rs2 => "Stage67BytecodeRegister::Rs2", + } +} + +fn emit_option_usize(value: Option) -> String { + value.map_or_else(|| "None".to_owned(), |value| format!("Some({value})")) +} + +fn rust_str(value: &str) -> String { + format!("{value:?}") +} + +fn rust_option_str(value: Option<&str>) -> String { + value.map_or_else( + || "None".to_owned(), + |value| format!("Some({})", rust_str(value)), + ) } #[cfg(test)] mod tests { use super::{ - stage6_bytecode_read_raf_plan, BytecodeFlag, BytecodeReadRafTermPlan, BytecodeRegister, + emit_stage6_bytecode_read_raf_plan_constants, BytecodeFlag, BytecodeReadRafTermPlan, + BytecodeRegister, STAGE6_BYTECODE_READ_RAF_PLAN, }; #[test] fn stage6_bytecode_plan_rows_encode_the_read_raf_reduction() { - let plan = stage6_bytecode_read_raf_plan(); + let plan = &STAGE6_BYTECODE_READ_RAF_PLAN; assert_eq!(plan.stages.len(), 5); assert_eq!(plan.entry_contribution.gamma_power, 7); @@ -378,4 +539,15 @@ mod tests { ] ); } + + #[test] + fn stage6_bytecode_plan_renderer_emits_stage67_constants() { + let source = emit_stage6_bytecode_read_raf_plan_constants(); + + assert!(source.contains("const STAGE6_BYTECODE_STAGE1_TERMS")); + assert!(source.contains("Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }")); + assert!(source.contains("Stage67BytecodeFlag::IsInterleaved")); + assert!(source.contains("Stage67BytecodeRegister::Rs2")); + assert!(source.contains("const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan")); + } } From 4c6c66be2afbeea1f44338fbb5cf0a39a8f3a894 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 21:28:55 -0600 Subject: [PATCH 044/171] refactor(bolt): share stage token helpers Move duplicated Stage 6 and Stage 7 Rust token helpers into plan_tokens. This keeps the active verifier emitters focused on stage structure while preserving generated verifier output. --- .../protocols/jolt/emit/rust/plan_tokens.rs | 88 +++++++++++++++++++ .../src/protocols/jolt/emit/rust/stage6.rs | 82 ++--------------- .../src/protocols/jolt/emit/rust/stage7.rs | 82 ++--------------- 3 files changed, 98 insertions(+), 154 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index 3eacf95087..95384945b8 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -1,3 +1,5 @@ +use std::collections::BTreeSet; + use crate::emit::rust::EmitError; use crate::ir::Role; @@ -57,6 +59,92 @@ pub(super) fn rust_str_slice_expr(values: &[String]) -> String { format!("&[{values}]") } +pub(super) fn rust_str(value: &str) -> String { + format!("{value:?}") +} + +pub(super) fn rust_option_str(value: Option<&str>) -> String { + value.map_or_else( + || "None".to_owned(), + |value| format!("Some({})", rust_str(value)), + ) +} + +pub(super) fn emit_str_array(name: &str, values: &[String]) -> String { + if values.is_empty() { + return format!("pub const {name}: &[&str] = &[];\n\n"); + } + if let [value] = values { + return format!("pub const {name}: &[&str] = &[{}];\n\n", rust_str(value)); + } + let entries = values + .iter() + .map(|value| format!(" {},", rust_str(value))) + .collect::>() + .join("\n"); + format!("pub const {name}: &[&str] = &[\n{entries}\n];\n\n") +} + +pub(super) fn emit_usize_array(name: &str, values: &[usize]) -> String { + let entries = values + .iter() + .map(usize::to_string) + .collect::>() + .join(", "); + format!("pub const {name}: &[usize] = &[{entries}];\n\n") +} + +pub(super) fn intern_str_array( + source: &mut String, + arrays: &mut Vec<(Vec, String)>, + name_prefix: &str, + values: &[String], +) -> String { + if let Some((_, name)) = arrays + .iter() + .find(|(existing, _)| existing.as_slice() == values) + { + return name.clone(); + } + let name = format!("{name_prefix}_{}", arrays.len()); + source.push_str(&emit_str_array(&name, values)); + arrays.push((values.to_vec(), name.clone())); + name +} + +pub(super) fn require_supported_symbol( + kind: &str, + actual: &str, + expected: &str, +) -> Result<(), EmitError> { + if actual == expected { + Ok(()) + } else { + Err(EmitError::new(format!( + "unsupported {kind} @{actual}; expected @{expected}" + ))) + } +} + +pub(super) fn verify_count( + kind: &str, + symbol: &str, + expected: usize, + actual: usize, +) -> Result<(), EmitError> { + if expected == actual { + Ok(()) + } else { + Err(EmitError::new(format!( + "{kind} @{symbol} count mismatch: expected {expected}, got {actual}" + ))) + } +} + +pub(super) fn symbols<'a>(values: impl Iterator) -> BTreeSet { + values.cloned().collect() +} + pub(super) fn role_relation_kind_expr( stage_type_prefix: &str, role: &Role, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index f3f9855f26..9c20eba564 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -25,6 +25,11 @@ use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, use crate::protocols::jolt::stage6_bytecode_read_raf_plan::emit_stage6_bytecode_read_raf_plan_constants; use crate::schema::verify_cpu_schema; +use super::plan_tokens::{ + emit_str_array, emit_usize_array, intern_str_array, require_supported_symbol, rust_option_str, + rust_str, symbols, verify_count, +}; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage6CpuProgram { pub role: Role, @@ -2610,83 +2615,6 @@ fn stage6_trace_rounds( } } -fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result<(), EmitError> { - if actual == expected { - Ok(()) - } else { - Err(EmitError::new(format!( - "unsupported {kind} @{actual}; expected @{expected}" - ))) - } -} - -fn emit_str_array(name: &str, values: &[String]) -> String { - if values.is_empty() { - return format!("pub const {name}: &[&str] = &[];\n\n"); - } - if let [value] = values { - return format!("pub const {name}: &[&str] = &[{}];\n\n", rust_str(value)); - } - let entries = values - .iter() - .map(|value| format!(" {},", rust_str(value))) - .collect::>() - .join("\n"); - format!("pub const {name}: &[&str] = &[\n{entries}\n];\n\n") -} - -fn emit_usize_array(name: &str, values: &[usize]) -> String { - let entries = values - .iter() - .map(usize::to_string) - .collect::>() - .join(", "); - format!("pub const {name}: &[usize] = &[{entries}];\n\n") -} - -fn intern_str_array( - source: &mut String, - arrays: &mut Vec<(Vec, String)>, - name_prefix: &str, - values: &[String], -) -> String { - if let Some((_, name)) = arrays - .iter() - .find(|(existing, _)| existing.as_slice() == values) - { - return name.clone(); - } - let name = format!("{name_prefix}_{}", arrays.len()); - source.push_str(&emit_str_array(&name, values)); - arrays.push((values.to_vec(), name.clone())); - name -} - -fn rust_str(value: &str) -> String { - format!("{value:?}") -} - -fn rust_option_str(value: Option<&str>) -> String { - value.map_or_else( - || "None".to_owned(), - |value| format!("Some({})", rust_str(value)), - ) -} - -fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Result<(), EmitError> { - if expected == actual { - Ok(()) - } else { - Err(EmitError::new(format!( - "{kind} @{symbol} count mismatch: expected {expected}, got {actual}" - ))) - } -} - -fn symbols<'a>(values: impl Iterator) -> BTreeSet { - values.cloned().collect() -} - fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index e9542d03ae..db340135c6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -24,6 +24,11 @@ use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::schema::verify_cpu_schema; +use super::plan_tokens::{ + emit_str_array, emit_usize_array, intern_str_array, require_supported_symbol, rust_option_str, + rust_str, symbols, verify_count, +}; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage7CpuProgram { pub role: Role, @@ -2477,83 +2482,6 @@ fn expected_batched_output_claim( } } -fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result<(), EmitError> { - if actual == expected { - Ok(()) - } else { - Err(EmitError::new(format!( - "unsupported {kind} @{actual}; expected @{expected}" - ))) - } -} - -fn emit_str_array(name: &str, values: &[String]) -> String { - if values.is_empty() { - return format!("pub const {name}: &[&str] = &[];\n\n"); - } - if let [value] = values { - return format!("pub const {name}: &[&str] = &[{}];\n\n", rust_str(value)); - } - let entries = values - .iter() - .map(|value| format!(" {},", rust_str(value))) - .collect::>() - .join("\n"); - format!("pub const {name}: &[&str] = &[\n{entries}\n];\n\n") -} - -fn emit_usize_array(name: &str, values: &[usize]) -> String { - let entries = values - .iter() - .map(usize::to_string) - .collect::>() - .join(", "); - format!("pub const {name}: &[usize] = &[{entries}];\n\n") -} - -fn intern_str_array( - source: &mut String, - arrays: &mut Vec<(Vec, String)>, - name_prefix: &str, - values: &[String], -) -> String { - if let Some((_, name)) = arrays - .iter() - .find(|(existing, _)| existing.as_slice() == values) - { - return name.clone(); - } - let name = format!("{name_prefix}_{}", arrays.len()); - source.push_str(&emit_str_array(&name, values)); - arrays.push((values.to_vec(), name.clone())); - name -} - -fn rust_str(value: &str) -> String { - format!("{value:?}") -} - -fn rust_option_str(value: Option<&str>) -> String { - value.map_or_else( - || "None".to_owned(), - |value| format!("Some({})", rust_str(value)), - ) -} - -fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Result<(), EmitError> { - if expected == actual { - Ok(()) - } else { - Err(EmitError::new(format!( - "{kind} @{symbol} count mismatch: expected {expected}, got {actual}" - ))) - } -} - -fn symbols<'a>(values: impl Iterator) -> BTreeSet { - values.cloned().collect() -} - fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) From 612b64958f701cb89925deb791fa357b28fd5313 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 21:35:51 -0600 Subject: [PATCH 045/171] refactor(bolt): table stage kernel ABI checks Make Stage 6 and Stage 7 kernel relation-to-ABI validation data-shaped. The ABI contract tables stay stage-local and generated verifier output remains unchanged. --- .../src/protocols/jolt/emit/rust/stage6.rs | 68 +++++++++++++++---- .../src/protocols/jolt/emit/rust/stage7.rs | 51 ++++++++++---- 2 files changed, 92 insertions(+), 27 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 9c20eba564..02c21eb7ac 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -30,6 +30,28 @@ use super::plan_tokens::{ rust_str, symbols, verify_count, }; +const STAGE6_KERNEL_ABIS: &[(&str, &str)] = &[ + ( + "jolt.stage6.bytecode_read_raf", + "jolt_stage6_bytecode_read_raf", + ), + ("jolt.stage6.booleanity", "jolt_stage6_booleanity"), + ( + "jolt.stage6.hamming_booleanity", + "jolt_stage6_hamming_booleanity", + ), + ("jolt.stage6.ram_ra_virtual", "jolt_stage6_ram_ra_virtual"), + ( + "jolt.stage6.instruction_ra_virtual", + "jolt_stage6_instruction_ra_virtual", + ), + ( + "jolt.stage6.inc_claim_reduction", + "jolt_stage6_inc_claim_reduction", + ), + ("jolt.stage6.batched", "jolt_stage6_batched"), +]; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage6CpuProgram { pub role: Role, @@ -794,21 +816,12 @@ impl Stage6CpuProgram { kernel.symbol, kernel.kind ))); } - let expected_abi = match kernel.relation.as_str() { - "jolt.stage6.bytecode_read_raf" => "jolt_stage6_bytecode_read_raf", - "jolt.stage6.booleanity" => "jolt_stage6_booleanity", - "jolt.stage6.hamming_booleanity" => "jolt_stage6_hamming_booleanity", - "jolt.stage6.ram_ra_virtual" => "jolt_stage6_ram_ra_virtual", - "jolt.stage6.instruction_ra_virtual" => "jolt_stage6_instruction_ra_virtual", - "jolt.stage6.inc_claim_reduction" => "jolt_stage6_inc_claim_reduction", - "jolt.stage6.batched" => "jolt_stage6_batched", - _ => { - return Err(EmitError::new(format!( - "unsupported stage6 kernel relation @{}", - kernel.relation - ))); - } - }; + let expected_abi = stage6_kernel_abi(&kernel.relation).ok_or_else(|| { + EmitError::new(format!( + "unsupported stage6 kernel relation @{}", + kernel.relation + )) + })?; if kernel.abi != expected_abi { return Err(EmitError::new(format!( "stage6 kernel @{} ABI `{}` does not match relation @{}", @@ -2615,6 +2628,12 @@ fn stage6_trace_rounds( } } +fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { + STAGE6_KERNEL_ABIS + .iter() + .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi)) +} + fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) @@ -2731,3 +2750,22 @@ fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { .unwrap_or("") .to_owned() } + +#[cfg(test)] +mod tests { + use super::{stage6_kernel_abi, STAGE6_KERNEL_ABIS}; + + #[test] + fn stage6_kernel_abi_contracts_cover_supported_relations() { + assert_eq!(STAGE6_KERNEL_ABIS.len(), 7); + assert_eq!( + stage6_kernel_abi("jolt.stage6.bytecode_read_raf"), + Some("jolt_stage6_bytecode_read_raf") + ); + assert_eq!( + stage6_kernel_abi("jolt.stage6.batched"), + Some("jolt_stage6_batched") + ); + assert_eq!(stage6_kernel_abi("jolt.stage7.batched"), None); + } +} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index db340135c6..5d9d501a9a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -29,6 +29,14 @@ use super::plan_tokens::{ rust_str, symbols, verify_count, }; +const STAGE7_KERNEL_ABIS: &[(&str, &str)] = &[ + ( + "jolt.stage7.hamming_weight_claim_reduction", + "jolt_stage7_hamming_weight_claim_reduction", + ), + ("jolt.stage7.batched", "jolt_stage7_batched"), +]; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage7CpuProgram { pub role: Role, @@ -793,18 +801,12 @@ impl Stage7CpuProgram { kernel.symbol, kernel.kind ))); } - let expected_abi = match kernel.relation.as_str() { - "jolt.stage7.hamming_weight_claim_reduction" => { - "jolt_stage7_hamming_weight_claim_reduction" - } - "jolt.stage7.batched" => "jolt_stage7_batched", - _ => { - return Err(EmitError::new(format!( - "unsupported stage7 kernel relation @{}", - kernel.relation - ))); - } - }; + let expected_abi = stage7_kernel_abi(&kernel.relation).ok_or_else(|| { + EmitError::new(format!( + "unsupported stage7 kernel relation @{}", + kernel.relation + )) + })?; if kernel.abi != expected_abi { return Err(EmitError::new(format!( "stage7 kernel @{} ABI `{}` does not match relation @{}", @@ -2482,6 +2484,12 @@ fn expected_batched_output_claim( } } +fn stage7_kernel_abi(relation: &str) -> Option<&'static str> { + STAGE7_KERNEL_ABIS + .iter() + .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi)) +} + fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) @@ -2598,3 +2606,22 @@ fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { .unwrap_or("") .to_owned() } + +#[cfg(test)] +mod tests { + use super::{stage7_kernel_abi, STAGE7_KERNEL_ABIS}; + + #[test] + fn stage7_kernel_abi_contracts_cover_supported_relations() { + assert_eq!(STAGE7_KERNEL_ABIS.len(), 2); + assert_eq!( + stage7_kernel_abi("jolt.stage7.hamming_weight_claim_reduction"), + Some("jolt_stage7_hamming_weight_claim_reduction") + ); + assert_eq!( + stage7_kernel_abi("jolt.stage7.batched"), + Some("jolt_stage7_batched") + ); + assert_eq!(stage7_kernel_abi("jolt.stage6.batched"), None); + } +} From 6cca7b5e74e98b1d83846a7b4910853554b28857 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 22:57:56 -0600 Subject: [PATCH 046/171] fix(bolt): evaluate output points before checks Evaluate generated point slice and concat plans before the batched expected-output checks in Stage 3 through Stage 7 verifiers. This fixes real-proof Stage 6 verification where the booleanity output claim referenced a derived point before observation had materialized it. Regenerate the verifier artifacts so the emitted Rust matches the emitter change. --- crates/bolt/src/protocols/jolt/artifacts.rs | 2 +- crates/bolt/src/protocols/jolt/emit/rust/stage3.rs | 9 +++++++++ crates/bolt/src/protocols/jolt/emit/rust/stage4.rs | 9 +++++++++ crates/bolt/src/protocols/jolt/emit/rust/stage5.rs | 9 +++++++++ crates/bolt/src/protocols/jolt/emit/rust/stage6.rs | 9 +++++++++ crates/bolt/src/protocols/jolt/emit/rust/stage7.rs | 9 +++++++++ crates/jolt-verifier/src/stages/stage3.rs | 9 +++++++++ crates/jolt-verifier/src/stages/stage4.rs | 9 +++++++++ crates/jolt-verifier/src/stages/stage5.rs | 9 +++++++++ crates/jolt-verifier/src/stages/stage6.rs | 9 +++++++++ crates/jolt-verifier/src/stages/stage7.rs | 9 +++++++++ 11 files changed, 91 insertions(+), 1 deletion(-) diff --git a/crates/bolt/src/protocols/jolt/artifacts.rs b/crates/bolt/src/protocols/jolt/artifacts.rs index fdc31cc3b8..7c12604c48 100644 --- a/crates/bolt/src/protocols/jolt/artifacts.rs +++ b/crates/bolt/src/protocols/jolt/artifacts.rs @@ -347,7 +347,7 @@ fn jolt_evaluation_role_api_extension() -> ProtocolArtifactExtension { required_artifact_stages: vec!["stage8".to_owned()], prover: ProtocolProverApiExtension { lib_module: jolt_prover_lib_module(), - imports: "#![expect(\n clippy::too_many_arguments,\n reason = \"generated prover helpers mirror staged protocol ABIs\"\n)]\n\nuse jolt_dory::{DoryCommitment, DoryHint, DoryProverSetup, DoryScheme};\nuse jolt_field::Fr;\nuse jolt_kernels::{stage1, stage2, stage3, stage4, stage5, stage6, stage7};\nuse jolt_openings::{AdditivelyHomomorphic, CommitmentScheme};\nuse jolt_poly::{EqPolynomial, Polynomial};\nuse jolt_transcript::{Blake2bTranscript, Transcript};\nuse jolt_verifier::{JoltEvaluationProof, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput};\nuse jolt_witness::{stage4_ram_val_init_opening, CycleInput, Stage45SparseTraceWitness, Stage6BytecodeEntry as WitnessStage6BytecodeEntry, Stage6WitnessParams, Stage6WitnessPolynomials, Stage6WitnessSlices};\nuse rayon::prelude::*;\n\n".to_owned(), + imports: "#![expect(\n clippy::too_many_arguments,\n reason = \"generated prover helpers mirror staged protocol ABIs\"\n)]\n\nuse jolt_dory::{DoryCommitment, DoryHint, DoryProverSetup, DoryScheme};\nuse jolt_field::Fr;\nuse jolt_kernels::{stage1, stage2, stage3, stage4, stage5, stage6, stage7};\nuse jolt_openings::CommitmentScheme;\nuse jolt_poly::{EqPolynomial, Polynomial};\nuse jolt_transcript::{Blake2bTranscript, Transcript};\nuse jolt_verifier::{JoltEvaluationProof, JoltNamedEval, JoltProof, JoltStage2RamAccess, JoltStage2RamData, JoltStage2RamOutputLayout, JoltStage6BytecodeEntry, JoltStage6BytecodeReadRafData, JoltStage6VerifierData, JoltStageChallengeVector, JoltStageExecutionArtifacts, JoltStageOpeningInputValue, JoltStageProof, JoltSumcheckOutput};\nuse jolt_witness::{stage4_ram_val_init_opening, CycleInput, Stage45SparseTraceWitness, Stage6BytecodeEntry as WitnessStage6BytecodeEntry, Stage6WitnessParams, Stage6WitnessPolynomials, Stage6WitnessSlices};\nuse rayon::prelude::*;\n\n".to_owned(), input_fields: " pub stage7_openings: Option<&'a [stage7::Stage7OpeningInputValue]>,\n" .to_owned(), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index aaa71e5874..ed35c95072 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -2004,6 +2004,15 @@ fn verify_batched_stage3( where T: Transcript, { + store.evaluate_available_points( + program.point_slices, + program.point_concats, + |input, expected, actual| VerifyStage3Error::InvalidInputLength { + input, + expected, + actual, + }, + )?; bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index d6853e9ea5..370166e540 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -2218,6 +2218,15 @@ fn verify_batched_stage4( where T: Transcript, { + store.evaluate_available_points( + program.point_slices, + program.point_concats, + |input, expected, actual| VerifyStage4Error::InvalidInputLength { + input, + expected, + actual, + }, + )?; bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 4b394ed94d..2926f2e736 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -2222,6 +2222,15 @@ fn verify_batched_stage5( where T: Transcript, { + store.evaluate_available_points( + program.point_slices, + program.point_concats, + |input, expected, actual| VerifyStage5Error::InvalidInputLength { + input, + expected, + actual, + }, + )?; bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 02c21eb7ac..009a20a0a1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -2420,6 +2420,15 @@ fn verify_batched_stage6( where T: Transcript, { + store.evaluate_available_points( + program.point_slices, + program.point_concats, + |input, expected, actual| VerifyStage6Error::InvalidInputLength { + input, + expected, + actual, + }, + )?; bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 5d9d501a9a..005354af59 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -2339,6 +2339,15 @@ fn verify_batched_stage7( where T: Transcript, { + store.evaluate_available_points( + program.point_slices, + program.point_concats, + |input, expected, actual| VerifyStage7Error::InvalidInputLength { + input, + expected, + actual, + }, + )?; bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index a7afe6dc41..f7eacddb52 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -384,6 +384,15 @@ fn verify_batched_stage3( where T: Transcript, { + store.evaluate_available_points( + program.point_slices, + program.point_concats, + |input, expected, actual| VerifyStage3Error::InvalidInputLength { + input, + expected, + actual, + }, + )?; bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index d7a8dd455a..424213dfa1 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -358,6 +358,15 @@ fn verify_batched_stage4( where T: Transcript, { + store.evaluate_available_points( + program.point_slices, + program.point_concats, + |input, expected, actual| VerifyStage4Error::InvalidInputLength { + input, + expected, + actual, + }, + )?; bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 39653d04c8..749464019f 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -469,6 +469,15 @@ fn verify_batched_stage5( where T: Transcript, { + store.evaluate_available_points( + program.point_slices, + program.point_concats, + |input, expected, actual| VerifyStage5Error::InvalidInputLength { + input, + expected, + actual, + }, + )?; bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 4b038614bb..0c86981a27 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -983,6 +983,15 @@ fn verify_batched_stage6( where T: Transcript, { + store.evaluate_available_points( + program.point_slices, + program.point_concats, + |input, expected, actual| VerifyStage6Error::InvalidInputLength { + input, + expected, + actual, + }, + )?; bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 738aa1f67c..dbd1d870eb 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -553,6 +553,15 @@ fn verify_batched_stage7( where T: Transcript, { + store.evaluate_available_points( + program.point_slices, + program.point_concats, + |input, expected, actual| VerifyStage7Error::InvalidInputLength { + input, + expected, + actual, + }, + )?; bolt_verifier_runtime::verify_batched_sumcheck( driver, proof, From 8db07c20422cc939f669f3b72a7dfdbb24c6bc72 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 23:07:55 -0600 Subject: [PATCH 047/171] refactor(bolt): add Jolt rust target plan ids Move verifier-facing CPU attr classification for program steps, transcript squeezes, claims, relations, field expressions, PCS modes, and opening equality modes into a Jolt Rust target planning module. Keep generated Rust output stable while making plan_tokens format typed Rust target IDs instead of owning the semantic match table. --- .../protocols/jolt/emit/rust/plan_tokens.rs | 123 ++---- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../src/protocols/jolt/rust_target_plan.rs | 412 ++++++++++++++++++ 3 files changed, 440 insertions(+), 96 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/rust_target_plan.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index 95384945b8..8bf9bc975a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -2,6 +2,10 @@ use std::collections::BTreeSet; use crate::emit::rust::EmitError; use crate::ir::Role; +use crate::protocols::jolt::rust_target_plan::{ + ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode, + ProgramStepKind, RustTargetPlanError, TranscriptSqueezeKind, +}; pub(super) fn role_program_step_kind_expr( stage_type_prefix: &str, @@ -181,109 +185,39 @@ pub(super) fn role_opening_equality_mode_expr( } fn program_step_kind_expr(stage_type_prefix: &str, kind: &str) -> Result { - let variant = match kind { - "transcript_squeeze" => "TranscriptSqueeze", - "transcript_absorb_bytes" => "TranscriptAbsorbBytes", - "sumcheck_driver" => "SumcheckDriver", - _ => return Err(unsupported("program step kind", kind)), - }; + let variant = ProgramStepKind::from_cpu_attr(kind) + .map_err(plan_error)? + .rust_variant(); Ok(format!("{stage_type_prefix}ProgramStepKind::{variant}")) } fn transcript_squeeze_kind_expr(stage_type_prefix: &str, kind: &str) -> Result { - let variant = match kind { - "challenge_scalar" => "ChallengeScalar", - "challenge_vector" => "ChallengeVector", - "scalar" => "Scalar", - _ => return Err(unsupported("transcript squeeze kind", kind)), - }; + let variant = TranscriptSqueezeKind::from_cpu_attr(kind) + .map_err(plan_error)? + .rust_variant(); Ok(format!( "{stage_type_prefix}TranscriptSqueezeKind::{variant}" )) } pub(super) fn claim_kind_expr(stage_type_prefix: &str, kind: &str) -> Result { - let variant = match kind { - "committed" => "Committed", - "virtual" => "Virtual", - _ => return Err(unsupported("opening claim kind", kind)), - }; + let variant = ClaimKind::from_cpu_attr(kind) + .map_err(plan_error)? + .rust_variant(); Ok(format!("{stage_type_prefix}ClaimKind::{variant}")) } fn relation_kind_expr(stage_type_prefix: &str, relation: &str) -> Result { - let variant = match relation { - "jolt.stage1.outer.uniskip" => "Stage1OuterUniskip", - "jolt.stage1.outer.remaining" => "Stage1OuterRemaining", - "jolt.stage2.product_virtual.uniskip" => "Stage2ProductVirtualUniskip", - "jolt.stage2.ram.read_write" => "Stage2RamReadWrite", - "jolt.stage2.product_virtual.remainder" => "Stage2ProductVirtualRemainder", - "jolt.stage2.instruction_lookup.claim_reduction" => "Stage2InstructionLookupClaimReduction", - "jolt.stage2.ram.raf_evaluation" => "Stage2RamRafEvaluation", - "jolt.stage2.ram.output_check" => "Stage2RamOutputCheck", - "jolt.stage2.batched" => "Stage2Batched", - "jolt.stage3.spartan_shift" => "Stage3SpartanShift", - "jolt.stage3.instruction_input" => "Stage3InstructionInput", - "jolt.stage3.registers_claim_reduction" => "Stage3RegistersClaimReduction", - "jolt.stage3.batched" => "Stage3Batched", - "jolt.stage4.registers_read_write" => "Stage4RegistersReadWrite", - "jolt.stage4.ram_val_check" => "Stage4RamValCheck", - "jolt.stage4.batched" => "Stage4Batched", - "jolt.stage5.instruction_read_raf" => "Stage5InstructionReadRaf", - "jolt.stage5.ram_ra_claim_reduction" => "Stage5RamRaClaimReduction", - "jolt.stage5.registers_val_evaluation" => "Stage5RegistersValEvaluation", - "jolt.stage5.batched" => "Stage5Batched", - "jolt.stage6.bytecode_read_raf" => "Stage6BytecodeReadRaf", - "jolt.stage6.booleanity" => "Stage6Booleanity", - "jolt.stage6.hamming_booleanity" => "Stage6HammingBooleanity", - "jolt.stage6.ram_ra_virtual" => "Stage6RamRaVirtual", - "jolt.stage6.instruction_ra_virtual" => "Stage6InstructionRaVirtual", - "jolt.stage6.inc_claim_reduction" => "Stage6IncClaimReduction", - "jolt.stage6.batched" => "Stage6Batched", - "jolt.stage7.hamming_weight_claim_reduction" => "Stage7HammingWeightClaimReduction", - "jolt.stage7.batched" => "Stage7Batched", - _ => return Err(unsupported("relation", relation)), - }; + let variant = JoltVerifierRelationKind::from_cpu_attr(relation) + .map_err(plan_error)? + .rust_variant(); Ok(format!("{stage_type_prefix}RelationKind::{variant}")) } fn field_expr_kind_expr(stage_type_prefix: &str, formula: &str) -> Result { - let variant = match formula { - "opening_eval" => "OpeningEval".to_owned(), - "field.add" => "Add".to_owned(), - "field.sub" => "Sub".to_owned(), - "field.mul" => "Mul".to_owned(), - "field.neg" => "Neg".to_owned(), - formula if formula.starts_with("field.pow:") => { - let Some(exponent) = formula.strip_prefix("field.pow:") else { - return Err(unsupported("field expression formula", formula)); - }; - let exponent = exponent - .parse::() - .map_err(|_| unsupported("field expression formula", formula))?; - format!("Pow({exponent})") - } - formula if formula.starts_with("poly.lagrange_basis_eval:") => { - let Some(spec) = formula.strip_prefix("poly.lagrange_basis_eval:") else { - return Err(unsupported("field expression formula", formula)); - }; - let parts = spec.split(':').collect::>(); - if parts.len() != 3 { - return Err(unsupported("field expression formula", formula)); - } - let domain_start = parts[0] - .parse::() - .map_err(|_| unsupported("field expression formula", formula))?; - let domain_size = parts[1] - .parse::() - .map_err(|_| unsupported("field expression formula", formula))?; - let index = parts[2] - .parse::() - .map_err(|_| unsupported("field expression formula", formula))?; - format!("LagrangeBasisEval({domain_start}, {domain_size}, {index})") - } - _ => return Err(unsupported("field expression formula", formula)), - }; + let variant = FieldExprKind::from_cpu_attr(formula) + .map_err(plan_error)? + .rust_variant_expr(); Ok(format!("{stage_type_prefix}FieldExprKind::{variant}")) } @@ -291,22 +225,19 @@ pub(super) fn pcs_proof_mode_expr( stage_type_prefix: &str, mode: &str, ) -> Result { - let variant = match mode { - "open" => "Open", - "verify" => "Verify", - _ => return Err(unsupported("PCS proof mode", mode)), - }; + let variant = PcsProofMode::from_cpu_attr(mode) + .map_err(plan_error)? + .rust_variant(); Ok(format!("{stage_type_prefix}PcsProofMode::{variant}")) } fn opening_equality_mode_expr(stage_type_prefix: &str, mode: &str) -> Result { - let variant = match mode { - "point_and_eval" => "PointAndEval", - _ => return Err(unsupported("opening equality mode", mode)), - }; + let variant = OpeningEqualityMode::from_cpu_attr(mode) + .map_err(plan_error)? + .rust_variant(); Ok(format!("{stage_type_prefix}OpeningEqualityMode::{variant}")) } -fn unsupported(kind: &str, value: &str) -> EmitError { - EmitError::new(format!("unsupported {kind} `{value}`")) +fn plan_error(error: RustTargetPlanError) -> EmitError { + EmitError::new(format!("unsupported {} `{}`", error.kind(), error.value())) } diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index 14141f2ecf..d4b352c418 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -3,6 +3,7 @@ pub mod emit; pub mod oracles; pub mod params; pub mod phases; +pub(crate) mod rust_target_plan; pub(crate) mod stage6_bytecode_read_raf_plan; pub mod validate; diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs new file mode 100644 index 0000000000..3e4ee0ff14 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -0,0 +1,412 @@ +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct RustTargetPlanError { + kind: &'static str, + value: String, +} + +impl RustTargetPlanError { + fn unsupported(kind: &'static str, value: &str) -> Self { + Self { + kind, + value: value.to_owned(), + } + } + + pub(crate) fn kind(&self) -> &'static str { + self.kind + } + + pub(crate) fn value(&self) -> &str { + &self.value + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum ProgramStepKind { + TranscriptSqueeze, + TranscriptAbsorbBytes, + SumcheckDriver, +} + +impl ProgramStepKind { + pub(crate) fn from_cpu_attr(value: &str) -> Result { + match value { + "transcript_squeeze" => Ok(Self::TranscriptSqueeze), + "transcript_absorb_bytes" => Ok(Self::TranscriptAbsorbBytes), + "sumcheck_driver" => Ok(Self::SumcheckDriver), + _ => Err(RustTargetPlanError::unsupported("program step kind", value)), + } + } + + pub(crate) fn rust_variant(self) -> &'static str { + match self { + Self::TranscriptSqueeze => "TranscriptSqueeze", + Self::TranscriptAbsorbBytes => "TranscriptAbsorbBytes", + Self::SumcheckDriver => "SumcheckDriver", + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum TranscriptSqueezeKind { + ChallengeScalar, + ChallengeVector, + Scalar, +} + +impl TranscriptSqueezeKind { + pub(crate) fn from_cpu_attr(value: &str) -> Result { + match value { + "challenge_scalar" => Ok(Self::ChallengeScalar), + "challenge_vector" => Ok(Self::ChallengeVector), + "scalar" => Ok(Self::Scalar), + _ => Err(RustTargetPlanError::unsupported( + "transcript squeeze kind", + value, + )), + } + } + + pub(crate) fn rust_variant(self) -> &'static str { + match self { + Self::ChallengeScalar => "ChallengeScalar", + Self::ChallengeVector => "ChallengeVector", + Self::Scalar => "Scalar", + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum ClaimKind { + Committed, + Virtual, +} + +impl ClaimKind { + pub(crate) fn from_cpu_attr(value: &str) -> Result { + match value { + "committed" => Ok(Self::Committed), + "virtual" => Ok(Self::Virtual), + _ => Err(RustTargetPlanError::unsupported( + "opening claim kind", + value, + )), + } + } + + pub(crate) fn rust_variant(self) -> &'static str { + match self { + Self::Committed => "Committed", + Self::Virtual => "Virtual", + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum JoltVerifierRelationKind { + Stage1OuterUniskip, + Stage1OuterRemaining, + Stage2ProductVirtualUniskip, + Stage2RamReadWrite, + Stage2ProductVirtualRemainder, + Stage2InstructionLookupClaimReduction, + Stage2RamRafEvaluation, + Stage2RamOutputCheck, + Stage2Batched, + Stage3SpartanShift, + Stage3InstructionInput, + Stage3RegistersClaimReduction, + Stage3Batched, + Stage4RegistersReadWrite, + Stage4RamValCheck, + Stage4Batched, + Stage5InstructionReadRaf, + Stage5RamRaClaimReduction, + Stage5RegistersValEvaluation, + Stage5Batched, + Stage6BytecodeReadRaf, + Stage6Booleanity, + Stage6HammingBooleanity, + Stage6RamRaVirtual, + Stage6InstructionRaVirtual, + Stage6IncClaimReduction, + Stage6Batched, + Stage7HammingWeightClaimReduction, + Stage7Batched, +} + +impl JoltVerifierRelationKind { + pub(crate) fn from_cpu_attr(value: &str) -> Result { + match value { + "jolt.stage1.outer.uniskip" => Ok(Self::Stage1OuterUniskip), + "jolt.stage1.outer.remaining" => Ok(Self::Stage1OuterRemaining), + "jolt.stage2.product_virtual.uniskip" => Ok(Self::Stage2ProductVirtualUniskip), + "jolt.stage2.ram.read_write" => Ok(Self::Stage2RamReadWrite), + "jolt.stage2.product_virtual.remainder" => Ok(Self::Stage2ProductVirtualRemainder), + "jolt.stage2.instruction_lookup.claim_reduction" => { + Ok(Self::Stage2InstructionLookupClaimReduction) + } + "jolt.stage2.ram.raf_evaluation" => Ok(Self::Stage2RamRafEvaluation), + "jolt.stage2.ram.output_check" => Ok(Self::Stage2RamOutputCheck), + "jolt.stage2.batched" => Ok(Self::Stage2Batched), + "jolt.stage3.spartan_shift" => Ok(Self::Stage3SpartanShift), + "jolt.stage3.instruction_input" => Ok(Self::Stage3InstructionInput), + "jolt.stage3.registers_claim_reduction" => Ok(Self::Stage3RegistersClaimReduction), + "jolt.stage3.batched" => Ok(Self::Stage3Batched), + "jolt.stage4.registers_read_write" => Ok(Self::Stage4RegistersReadWrite), + "jolt.stage4.ram_val_check" => Ok(Self::Stage4RamValCheck), + "jolt.stage4.batched" => Ok(Self::Stage4Batched), + "jolt.stage5.instruction_read_raf" => Ok(Self::Stage5InstructionReadRaf), + "jolt.stage5.ram_ra_claim_reduction" => Ok(Self::Stage5RamRaClaimReduction), + "jolt.stage5.registers_val_evaluation" => Ok(Self::Stage5RegistersValEvaluation), + "jolt.stage5.batched" => Ok(Self::Stage5Batched), + "jolt.stage6.bytecode_read_raf" => Ok(Self::Stage6BytecodeReadRaf), + "jolt.stage6.booleanity" => Ok(Self::Stage6Booleanity), + "jolt.stage6.hamming_booleanity" => Ok(Self::Stage6HammingBooleanity), + "jolt.stage6.ram_ra_virtual" => Ok(Self::Stage6RamRaVirtual), + "jolt.stage6.instruction_ra_virtual" => Ok(Self::Stage6InstructionRaVirtual), + "jolt.stage6.inc_claim_reduction" => Ok(Self::Stage6IncClaimReduction), + "jolt.stage6.batched" => Ok(Self::Stage6Batched), + "jolt.stage7.hamming_weight_claim_reduction" => { + Ok(Self::Stage7HammingWeightClaimReduction) + } + "jolt.stage7.batched" => Ok(Self::Stage7Batched), + _ => Err(RustTargetPlanError::unsupported("relation", value)), + } + } + + pub(crate) fn rust_variant(self) -> &'static str { + match self { + Self::Stage1OuterUniskip => "Stage1OuterUniskip", + Self::Stage1OuterRemaining => "Stage1OuterRemaining", + Self::Stage2ProductVirtualUniskip => "Stage2ProductVirtualUniskip", + Self::Stage2RamReadWrite => "Stage2RamReadWrite", + Self::Stage2ProductVirtualRemainder => "Stage2ProductVirtualRemainder", + Self::Stage2InstructionLookupClaimReduction => "Stage2InstructionLookupClaimReduction", + Self::Stage2RamRafEvaluation => "Stage2RamRafEvaluation", + Self::Stage2RamOutputCheck => "Stage2RamOutputCheck", + Self::Stage2Batched => "Stage2Batched", + Self::Stage3SpartanShift => "Stage3SpartanShift", + Self::Stage3InstructionInput => "Stage3InstructionInput", + Self::Stage3RegistersClaimReduction => "Stage3RegistersClaimReduction", + Self::Stage3Batched => "Stage3Batched", + Self::Stage4RegistersReadWrite => "Stage4RegistersReadWrite", + Self::Stage4RamValCheck => "Stage4RamValCheck", + Self::Stage4Batched => "Stage4Batched", + Self::Stage5InstructionReadRaf => "Stage5InstructionReadRaf", + Self::Stage5RamRaClaimReduction => "Stage5RamRaClaimReduction", + Self::Stage5RegistersValEvaluation => "Stage5RegistersValEvaluation", + Self::Stage5Batched => "Stage5Batched", + Self::Stage6BytecodeReadRaf => "Stage6BytecodeReadRaf", + Self::Stage6Booleanity => "Stage6Booleanity", + Self::Stage6HammingBooleanity => "Stage6HammingBooleanity", + Self::Stage6RamRaVirtual => "Stage6RamRaVirtual", + Self::Stage6InstructionRaVirtual => "Stage6InstructionRaVirtual", + Self::Stage6IncClaimReduction => "Stage6IncClaimReduction", + Self::Stage6Batched => "Stage6Batched", + Self::Stage7HammingWeightClaimReduction => "Stage7HammingWeightClaimReduction", + Self::Stage7Batched => "Stage7Batched", + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum FieldExprKind { + OpeningEval, + Add, + Sub, + Mul, + Neg, + Pow(usize), + LagrangeBasisEval { + domain_start: i64, + domain_size: usize, + index: usize, + }, +} + +impl FieldExprKind { + pub(crate) fn from_cpu_attr(value: &str) -> Result { + match value { + "opening_eval" => Ok(Self::OpeningEval), + "field.add" => Ok(Self::Add), + "field.sub" => Ok(Self::Sub), + "field.mul" => Ok(Self::Mul), + "field.neg" => Ok(Self::Neg), + value if value.starts_with("field.pow:") => parse_pow(value), + value if value.starts_with("poly.lagrange_basis_eval:") => parse_lagrange(value), + _ => Err(RustTargetPlanError::unsupported( + "field expression formula", + value, + )), + } + } + + pub(crate) fn rust_variant_expr(self) -> String { + match self { + Self::OpeningEval => "OpeningEval".to_owned(), + Self::Add => "Add".to_owned(), + Self::Sub => "Sub".to_owned(), + Self::Mul => "Mul".to_owned(), + Self::Neg => "Neg".to_owned(), + Self::Pow(exponent) => format!("Pow({exponent})"), + Self::LagrangeBasisEval { + domain_start, + domain_size, + index, + } => format!("LagrangeBasisEval({domain_start}, {domain_size}, {index})"), + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum PcsProofMode { + Open, + Verify, +} + +impl PcsProofMode { + pub(crate) fn from_cpu_attr(value: &str) -> Result { + match value { + "open" => Ok(Self::Open), + "verify" => Ok(Self::Verify), + _ => Err(RustTargetPlanError::unsupported("PCS proof mode", value)), + } + } + + pub(crate) fn rust_variant(self) -> &'static str { + match self { + Self::Open => "Open", + Self::Verify => "Verify", + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum OpeningEqualityMode { + PointAndEval, +} + +impl OpeningEqualityMode { + pub(crate) fn from_cpu_attr(value: &str) -> Result { + match value { + "point_and_eval" => Ok(Self::PointAndEval), + _ => Err(RustTargetPlanError::unsupported( + "opening equality mode", + value, + )), + } + } + + pub(crate) fn rust_variant(self) -> &'static str { + match self { + Self::PointAndEval => "PointAndEval", + } + } +} + +fn parse_pow(value: &str) -> Result { + let exponent = value + .strip_prefix("field.pow:") + .and_then(|exponent| exponent.parse::().ok()) + .ok_or_else(|| RustTargetPlanError::unsupported("field expression formula", value))?; + Ok(FieldExprKind::Pow(exponent)) +} + +fn parse_lagrange(value: &str) -> Result { + let spec = value + .strip_prefix("poly.lagrange_basis_eval:") + .ok_or_else(|| RustTargetPlanError::unsupported("field expression formula", value))?; + let parts = spec.split(':').collect::>(); + let [domain_start, domain_size, index] = parts.as_slice() else { + return Err(RustTargetPlanError::unsupported( + "field expression formula", + value, + )); + }; + let domain_start = domain_start + .parse::() + .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; + let domain_size = domain_size + .parse::() + .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; + let index = index + .parse::() + .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; + Ok(FieldExprKind::LagrangeBasisEval { + domain_start, + domain_size, + index, + }) +} + +#[cfg(test)] +mod tests { + use super::{ + ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode, + ProgramStepKind, TranscriptSqueezeKind, + }; + + #[test] + fn parses_typed_rust_target_ids_from_cpu_attrs() { + assert_eq!( + ProgramStepKind::from_cpu_attr("sumcheck_driver").ok(), + Some(ProgramStepKind::SumcheckDriver) + ); + assert_eq!( + TranscriptSqueezeKind::from_cpu_attr("challenge_vector").ok(), + Some(TranscriptSqueezeKind::ChallengeVector) + ); + assert_eq!( + ClaimKind::from_cpu_attr("virtual").ok(), + Some(ClaimKind::Virtual) + ); + assert_eq!( + JoltVerifierRelationKind::from_cpu_attr("jolt.stage6.booleanity").ok(), + Some(JoltVerifierRelationKind::Stage6Booleanity) + ); + assert_eq!( + PcsProofMode::from_cpu_attr("verify").ok(), + Some(PcsProofMode::Verify) + ); + assert_eq!( + OpeningEqualityMode::from_cpu_attr("point_and_eval").ok(), + Some(OpeningEqualityMode::PointAndEval) + ); + } + + #[test] + fn parses_compound_field_expr_kinds() { + assert_eq!( + FieldExprKind::from_cpu_attr("field.pow:32").ok(), + Some(FieldExprKind::Pow(32)) + ); + assert_eq!( + FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:-1:3:2").ok(), + Some(FieldExprKind::LagrangeBasisEval { + domain_start: -1, + domain_size: 3, + index: 2, + }) + ); + assert!(FieldExprKind::from_cpu_attr("field.pow:nope").is_err()); + assert!(FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:1:2").is_err()); + } + + #[test] + fn emits_generated_rust_variant_names_without_cpu_attr_spelling() { + assert_eq!( + JoltVerifierRelationKind::Stage5RegistersValEvaluation.rust_variant(), + "Stage5RegistersValEvaluation" + ); + assert_eq!( + FieldExprKind::LagrangeBasisEval { + domain_start: -1, + domain_size: 3, + index: 0, + } + .rust_variant_expr(), + "LagrangeBasisEval(-1, 3, 0)" + ); + } +} From bfad0e9e0f43a73b897bfac64754fdfe61ec9001 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 23:22:29 -0600 Subject: [PATCH 048/171] refactor(bolt): preflight stage2 verifier target Run Stage 2 verifier-facing CPU attrs through the typed Jolt Rust target classifier before emission. This keeps generated artifacts stable while ensuring unsupported verifier step kinds, transcript squeeze kinds, claim kinds, field expression formulas, and Jolt relation IDs fail in target verification rather than only during token formatting. --- .../protocols/jolt/emit/rust/plan_tokens.rs | 2 +- .../src/protocols/jolt/emit/rust/stage2.rs | 53 ++++++++++++++++++- .../src/protocols/jolt/rust_target_plan.rs | 12 ++--- 3 files changed, 59 insertions(+), 8 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index 8bf9bc975a..c64ee1f715 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -239,5 +239,5 @@ fn opening_equality_mode_expr(stage_type_prefix: &str, mode: &str) -> Result EmitError { - EmitError::new(format!("unsupported {} `{}`", error.kind(), error.value())) + EmitError::new(error.to_string()) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 7bcff9db01..9939fd0b8f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -6,6 +6,10 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::rust_target_plan::{ + ClaimKind, FieldExprKind, JoltVerifierRelationKind, ProgramStepKind, RustTargetPlanError, + TranscriptSqueezeKind, +}; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] @@ -513,7 +517,10 @@ impl Stage2CpuProgram { self.verify_kernel_definitions()?; self.verify_prover_driver_bindings()?; } - Role::Verifier => self.verify_verifier_driver_bindings()?, + Role::Verifier => { + self.verify_verifier_driver_bindings()?; + self.verify_verifier_rust_target()?; + } } self.verify_opening_flow() } @@ -765,6 +772,46 @@ impl Stage2CpuProgram { Ok(()) } + fn verify_verifier_rust_target(&self) -> Result<(), EmitError> { + for step in &self.steps { + let _ = ProgramStepKind::from_cpu_attr(&step.kind).map_err(rust_target_plan_error)?; + } + for squeeze in &self.transcript_squeezes { + let _ = TranscriptSqueezeKind::from_cpu_attr(&squeeze.kind) + .map_err(rust_target_plan_error)?; + } + for input in &self.opening_inputs { + let _ = ClaimKind::from_cpu_attr(&input.claim_kind).map_err(rust_target_plan_error)?; + } + for expr in &self.field_exprs { + let _ = FieldExprKind::from_cpu_attr(&expr.formula).map_err(rust_target_plan_error)?; + } + for claim in &self.claims { + let relation = claim + .relation + .as_deref() + .ok_or_else(|| missing_role_binding("verifier claim relation", &claim.symbol))?; + let _ = JoltVerifierRelationKind::from_cpu_attr(relation) + .map_err(rust_target_plan_error)?; + } + for driver in &self.drivers { + let relation = driver + .relation + .as_deref() + .ok_or_else(|| missing_role_binding("verifier driver relation", &driver.symbol))?; + let _ = JoltVerifierRelationKind::from_cpu_attr(relation) + .map_err(rust_target_plan_error)?; + } + for instance in &self.instance_results { + let _ = JoltVerifierRelationKind::from_cpu_attr(&instance.relation) + .map_err(rust_target_plan_error)?; + } + for claim in &self.opening_claims { + let _ = ClaimKind::from_cpu_attr(&claim.claim_kind).map_err(rust_target_plan_error)?; + } + Ok(()) + } + fn verify_opening_flow(&self) -> Result<(), EmitError> { let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); point_sources.extend(symbols( @@ -2440,6 +2487,10 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } +fn rust_target_plan_error(error: RustTargetPlanError) -> EmitError { + EmitError::new(error.to_string()) +} + fn emit_str_array(name: &str, values: &[String]) -> String { if values.is_empty() { return format!("pub const {name}: &[&str] = &[];\n\n"); diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index 3e4ee0ff14..81ea211016 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -1,3 +1,5 @@ +use std::fmt::{self, Display, Formatter}; + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct RustTargetPlanError { kind: &'static str, @@ -11,13 +13,11 @@ impl RustTargetPlanError { value: value.to_owned(), } } +} - pub(crate) fn kind(&self) -> &'static str { - self.kind - } - - pub(crate) fn value(&self) -> &str { - &self.value +impl Display for RustTargetPlanError { + fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result { + write!(formatter, "unsupported {} `{}`", self.kind, self.value) } } From 4d9df7f2c367d2e01f1e0e145ef53b0ae52c91fb Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 23:27:49 -0600 Subject: [PATCH 049/171] refactor(poly): reuse LtPolynomial in verifier runtime --- crates/bolt-verifier-runtime/src/lib.rs | 21 ++++++-------------- crates/jolt-poly/src/lt.rs | 26 +++++++++++++++++++++++++ 2 files changed, 32 insertions(+), 15 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index f286e7cb74..d84b50367a 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -8,7 +8,7 @@ use std::fmt; use std::marker::PhantomData; use jolt_field::{Field, Fr, MulPow2}; -use jolt_poly::{lagrange::lagrange_evals, EqPlusOnePolynomial, EqPolynomial}; +use jolt_poly::{lagrange::lagrange_evals, EqPlusOnePolynomial, EqPolynomial, LtPolynomial}; use jolt_sumcheck::{ CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier, }; @@ -1443,20 +1443,11 @@ fn evaluate_structured_polynomial( } fn evaluate_lt_polynomial_mle(x: &[Fr], y: &[Fr]) -> Result { - if x.len() != y.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: "sumcheck_output.lt", - expected: x.len(), - actual: y.len(), - }); - } - let mut lt_eval = Fr::from_u64(0); - let mut eq_term = Fr::from_u64(1); - for (x_i, y_i) in x.iter().zip(y) { - lt_eval += (Fr::from_u64(1) - *x_i) * *y_i * eq_term; - eq_term *= Fr::from_u64(1) - *x_i - *y_i + *x_i * *y_i + *x_i * *y_i; - } - Ok(lt_eval) + LtPolynomial::try_evaluate(x, y).ok_or(RuntimePlanError::InvalidInputLength { + input: "sumcheck_output.lt", + expected: x.len(), + actual: y.len(), + }) } #[derive(Default)] diff --git a/crates/jolt-poly/src/lt.rs b/crates/jolt-poly/src/lt.rs index c220ff6a6d..9dee26837b 100644 --- a/crates/jolt-poly/src/lt.rs +++ b/crates/jolt-poly/src/lt.rs @@ -124,6 +124,20 @@ impl LtPolynomial { /// Both `x` and `r` are big-endian. Time: O(n). Space: O(1). pub fn evaluate(x: &[F], r: &[F]) -> F { assert_eq!(x.len(), r.len(), "LT point dimension mismatch"); + Self::evaluate_equal_length(x, r) + } + + /// Fallible version of [`evaluate`](Self::evaluate) for verifier-side callers. + /// + /// Returns `None` when the two points have different dimensions. + pub fn try_evaluate(x: &[F], r: &[F]) -> Option { + if x.len() != r.len() { + return None; + } + Some(Self::evaluate_equal_length(x, r)) + } + + fn evaluate_equal_length(x: &[F], r: &[F]) -> F { let mut lt = F::zero(); let mut eq_prefix = F::one(); for (&xi, &ri) in x.iter().zip(r.iter()) { @@ -220,6 +234,18 @@ mod tests { } } + #[test] + fn try_evaluate_checks_dimension() { + let x = vec![Fr::zero(), Fr::one()]; + let r = vec![Fr::one(), Fr::zero()]; + + assert_eq!( + LtPolynomial::try_evaluate(&x, &r), + Some(LtPolynomial::evaluate(&x, &r)) + ); + assert_eq!(LtPolynomial::try_evaluate(&x, &r[..1]), None); + } + #[test] fn split_matches_full_table() { let mut rng = ChaCha20Rng::seed_from_u64(99); From 0774ba9e1b15261a5671d01ec6a1f0b3035fee1d Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 23:32:40 -0600 Subject: [PATCH 050/171] refactor(poly): move indexed eq evaluation to jolt-poly --- crates/bolt-verifier-runtime/src/lib.rs | 14 ------ .../jolt/verifier_jolt_relations.rs.template | 21 ++++++-- crates/jolt-poly/src/eq.rs | 48 +++++++++++++++++++ .../src/stages/jolt_relations.rs | 21 ++++++-- 4 files changed, 80 insertions(+), 24 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index d84b50367a..cb96bdee9a 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -1632,20 +1632,6 @@ pub fn evaluate_field_expr( } } -pub fn indexed_boolean_eq(index: usize, point: &[Fr]) -> Fr { - point - .iter() - .enumerate() - .map(|(bit, value)| { - if (index >> (point.len() - 1 - bit)) & 1 == 1 { - *value - } else { - Fr::from_u64(1) - *value - } - }) - .product() -} - pub fn field_powers(base: Fr, count: usize) -> Vec { let mut powers = Vec::with_capacity(count); let mut power = Fr::from_u64(1); diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 678922cbf3..965bd3a077 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -29,9 +29,8 @@ use jolt_field::{Field, Fr, MulPow2}; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - field_powers, indexed_boolean_eq, indexed_evals_by_prefix_any, prefix_point, store_point, - store_scalar, suffix_point, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, - ValueStore, + field_powers, indexed_evals_by_prefix_any, prefix_point, store_point, store_scalar, + suffix_point, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -312,7 +311,13 @@ fn stage67_bytecode_stage_value_evals( let mut evals = vec![Fr::from_u64(0); plan.stages.len()]; for (index, entry) in entries.iter().enumerate() { - let eq = indexed_boolean_eq(index, r_address); + let eq = EqPolynomial::::try_mle_at_boolean_index(index, r_address).ok_or( + RuntimePlanError::InvalidInputLength { + input: plan.entries, + expected: expected_len, + actual: index + 1, + }, + )?; let values = stage67_bytecode_entry_stage_values(plan, entry, &stage_contexts)?; for stage in 0..evals.len() { evals[stage] += eq * values[stage]; @@ -487,7 +492,13 @@ fn stage67_register_eq( actual: index + 1, }); } - Ok(indexed_boolean_eq(index, point)) + EqPolynomial::::try_mle_at_boolean_index(index, point).ok_or( + RuntimePlanError::InvalidInputLength { + input, + expected: register_count, + actual: index + 1, + }, + ) } fn stage67_register_prefix_point<'a>( diff --git a/crates/jolt-poly/src/eq.rs b/crates/jolt-poly/src/eq.rs index 206daec033..8ee4601da6 100644 --- a/crates/jolt-poly/src/eq.rs +++ b/crates/jolt-poly/src/eq.rs @@ -139,6 +139,35 @@ impl EqPolynomial { .fold(F::one(), |acc, v| acc * v) } + /// Evaluates `eq(point, index_bits)` where `index_bits` is the big-endian + /// Boolean vector encoded by `index`. + /// + /// Returns `None` if `point` is too large to address with `usize`, or if + /// `index` is outside the Boolean hypercube for `point.len()` variables. + pub fn try_mle_at_boolean_index(index: usize, point: &[C]) -> Option + where + C: Copy + Into, + { + let count = 1usize.checked_shl(point.len() as u32)?; + if index >= count { + return None; + } + Some( + point + .iter() + .enumerate() + .map(|(bit, value)| { + let value = (*value).into(); + if (index >> (point.len() - 1 - bit)) & 1 == 1 { + value + } else { + F::one() - value + } + }) + .product(), + ) + } + /// Computes `eq(r, 0) = Π_i (1 - r_i)`, selecting the all-zeros vertex. pub fn zero_selector(r: &[C]) -> F where @@ -391,6 +420,25 @@ mod tests { } } + #[test] + fn try_mle_at_boolean_index_selects_entry() { + let mut rng = ChaCha20Rng::seed_from_u64(101); + let n = 4; + let point: Vec = (0..n).map(|_| Fr::random(&mut rng)).collect(); + let table = EqPolynomial::new(point.clone()).evaluations(); + + for (index, &entry) in table.iter().enumerate() { + assert_eq!( + EqPolynomial::::try_mle_at_boolean_index(index, &point), + Some(entry) + ); + } + assert_eq!( + EqPolynomial::::try_mle_at_boolean_index(table.len(), &point), + None + ); + } + #[test] fn evaluations_matches_evaluate_pointwise() { let mut rng = ChaCha20Rng::seed_from_u64(7); diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 678922cbf3..965bd3a077 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -29,9 +29,8 @@ use jolt_field::{Field, Fr, MulPow2}; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - field_powers, indexed_boolean_eq, indexed_evals_by_prefix_any, prefix_point, store_point, - store_scalar, suffix_point, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, - ValueStore, + field_powers, indexed_evals_by_prefix_any, prefix_point, store_point, store_scalar, + suffix_point, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -312,7 +311,13 @@ fn stage67_bytecode_stage_value_evals( let mut evals = vec![Fr::from_u64(0); plan.stages.len()]; for (index, entry) in entries.iter().enumerate() { - let eq = indexed_boolean_eq(index, r_address); + let eq = EqPolynomial::::try_mle_at_boolean_index(index, r_address).ok_or( + RuntimePlanError::InvalidInputLength { + input: plan.entries, + expected: expected_len, + actual: index + 1, + }, + )?; let values = stage67_bytecode_entry_stage_values(plan, entry, &stage_contexts)?; for stage in 0..evals.len() { evals[stage] += eq * values[stage]; @@ -487,7 +492,13 @@ fn stage67_register_eq( actual: index + 1, }); } - Ok(indexed_boolean_eq(index, point)) + EqPolynomial::::try_mle_at_boolean_index(index, point).ok_or( + RuntimePlanError::InvalidInputLength { + input, + expected: register_count, + actual: index + 1, + }, + ) } fn stage67_register_prefix_point<'a>( From b7b3d5aebb944cc573c791edd67db92c94eca8ce Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 23:43:59 -0600 Subject: [PATCH 051/171] refactor(bolt): replace eval prefix reconstruction --- crates/bolt-verifier-runtime/src/lib.rs | 88 ++++-------------- .../src/protocols/jolt/emit/rust/stage5.rs | 93 +++++++++++++++++-- .../jolt/stage6_bytecode_read_raf_plan.rs | 44 ++++++++- .../jolt/verifier_jolt_relations.rs.template | 8 +- .../src/stages/jolt_relations.rs | 8 +- crates/jolt-verifier/src/stages/stage5.rs | 20 ++-- crates/jolt-verifier/src/stages/stage6.rs | 6 +- 7 files changed, 169 insertions(+), 98 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index cb96bdee9a..98bf2d6ad1 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -599,6 +599,12 @@ pub struct StageNamedEval { pub value: F, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct NamedEvalFamilyPlan { + pub symbol: &'static str, + pub evals: &'static [&'static str], +} + #[derive(Clone, Debug, Serialize)] pub struct StageSumcheckOutput { pub driver: &'static str, @@ -1193,6 +1199,17 @@ pub fn eval_by_name( .ok_or(RuntimePlanError::MissingValue { symbol: name }) } +pub fn eval_family_values( + evals: &[StageNamedEval], + family: &NamedEvalFamilyPlan, +) -> Result, RuntimePlanError> { + family + .evals + .iter() + .map(|&name| eval_by_name(evals, name)) + .collect() +} + pub fn evaluate_sumcheck_output_claim( plan: &SumcheckOutputClaimPlan, field_exprs: &[FieldExprPlan], @@ -1496,77 +1513,6 @@ fn evaluate_available_field_exprs_with_scratch( } } -pub fn indexed_evals_by_prefix( - evals: &[StageNamedEval], - prefix: &'static str, - count: usize, -) -> Result, RuntimePlanError> { - let mut values = vec![None; count]; - for eval in evals { - let Some(suffix) = eval.name.strip_prefix(prefix) else { - continue; - }; - let index = suffix - .parse::() - .map_err(|_| RuntimePlanError::InvalidProof { - driver: prefix, - reason: "invalid indexed eval suffix", - })?; - if index >= count || values[index].is_some() { - return Err(RuntimePlanError::InvalidProof { - driver: prefix, - reason: "invalid indexed eval", - }); - } - values[index] = Some(eval.value); - } - values - .into_iter() - .map(|value| value.ok_or(RuntimePlanError::MissingValue { symbol: prefix })) - .collect() -} - -pub fn indexed_evals_by_prefix_any( - evals: &[StageNamedEval], - prefix: &'static str, -) -> Result, RuntimePlanError> { - let mut indexed_values = Vec::new(); - for eval in evals { - let Some(suffix) = eval.name.strip_prefix(prefix) else { - continue; - }; - let index = suffix - .parse::() - .map_err(|_| RuntimePlanError::InvalidProof { - driver: prefix, - reason: "invalid indexed eval suffix", - })?; - if indexed_values - .iter() - .any(|(existing_index, _)| *existing_index == index) - { - return Err(RuntimePlanError::InvalidProof { - driver: prefix, - reason: "duplicate indexed eval", - }); - } - indexed_values.push((index, eval.value)); - } - if indexed_values.is_empty() { - return Err(RuntimePlanError::MissingValue { symbol: prefix }); - } - indexed_values.sort_by_key(|(index, _)| *index); - for (expected, (actual, _)) in indexed_values.iter().enumerate() { - if *actual != expected { - return Err(RuntimePlanError::InvalidProof { - driver: prefix, - reason: "non-contiguous indexed eval", - }); - } - } - Ok(indexed_values.into_iter().map(|(_, value)| value).collect()) -} - pub fn single_operand( symbol: &'static str, operands: &[F], diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 2926f2e736..ff850b688a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1080,7 +1080,7 @@ impl Stage5CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice};\n\ + "use bolt_verifier_runtime::{batch_claims, eval_by_name, eval_family_values, find_batch, find_plan, reverse_slice, NamedEvalFamilyPlan};\n\ use super::jolt_relations::{identity_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval};\n\ use jolt_field::{Field, Fr};\n\ use jolt_lookup_tables::LookupTableKind;\n\ @@ -1809,6 +1809,9 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); let mut source = String::new(); source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); + if self.role == Role::Verifier { + source.push_str(&self.emit_named_eval_family_constants()?); + } source.push_str(&self.emit_point_slice_constants()); source.push_str(&self.emit_point_concat_constants()); source.push_str(&self.emit_opening_claim_constants()?); @@ -1866,6 +1869,84 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); format!("pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[\n{evals}\n];\n\n") } + fn emit_named_eval_family_constants(&self) -> Result { + const FAMILIES: &[(&str, &str, &str, &str)] = &[ + ( + "STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVAL_NAMES", + "STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS", + "stage5.instruction_read_raf.eval.LookupTableFlag", + "LookupTableFlag_", + ), + ( + "STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES", + "STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS", + "stage5.instruction_read_raf.eval.InstructionRa", + "InstructionRa_", + ), + ]; + + let mut source = String::new(); + for (names_const, family_const, family_symbol, oracle_prefix) in FAMILIES { + let names = self.indexed_eval_family_names(family_symbol, oracle_prefix)?; + let names_source = names + .iter() + .map(|name| rust_str(name)) + .collect::>() + .join(", "); + push_format( + &mut source, + format_args!( + "#[rustfmt::skip]\npub const {names_const}: &[&str] = &[{names_source}];\n" + ), + ); + push_format( + &mut source, + format_args!( + "pub const {family_const}: NamedEvalFamilyPlan = NamedEvalFamilyPlan {{ symbol: {}, evals: {names_const} }};\n\n", + rust_str(family_symbol), + ), + ); + } + Ok(source) + } + + fn indexed_eval_family_names( + &self, + family_symbol: &str, + oracle_prefix: &str, + ) -> Result, EmitError> { + let mut indexed_names = Vec::new(); + for eval in &self.evals { + let Some(suffix) = eval.oracle.strip_prefix(oracle_prefix) else { + continue; + }; + let index = suffix.parse::().map_err(|_| { + EmitError::new(format!( + "invalid indexed eval oracle `{}` for family `{family_symbol}`", + eval.oracle + )) + })?; + indexed_names.push((index, eval.name.as_str())); + } + if indexed_names.is_empty() { + return Err(EmitError::new(format!( + "missing eval family `{family_symbol}`" + ))); + } + indexed_names.sort_by_key(|(index, _)| *index); + for (expected, (actual, _)) in indexed_names.iter().enumerate() { + if expected != *actual { + return Err(EmitError::new(format!( + "non-contiguous eval family `{family_symbol}` at index {actual}" + ))); + } + } + Ok(indexed_names + .into_iter() + .map(|(_, name)| name) + .collect::>()) + } + fn emit_verifier_output_claim_constants(&self) -> Result { super::output_claims::emit_verifier_output_claim_constants( "Stage5", @@ -2404,10 +2485,8 @@ fn expected_instruction_read_raf( let right_operand_eval = operand_polynomial_eval(r_address_prime, false); let identity_poly_eval = identity_polynomial_eval(r_address_prime); - let table_flag_claims = indexed_evals_by_prefix_any( - evals, - "stage5.instruction_read_raf.eval.LookupTableFlag_", - )?; + let table_flag_claims = + eval_family_values(evals, &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS)?; let table_values = LookupTableKind::::all() .iter() .take(table_flag_claims.len()) @@ -2419,9 +2498,9 @@ fn expected_instruction_read_raf( .map(|(table_value, flag_claim)| table_value * flag_claim) .sum::(); - let ra_claim = indexed_evals_by_prefix_any( + let ra_claim = eval_family_values( evals, - "stage5.instruction_read_raf.eval.InstructionRa_", + &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS, )? .into_iter() .product::(); diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 195439cf20..0ae285a8b4 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -5,7 +5,10 @@ pub(crate) struct BytecodeReadRafPlan { pub(crate) const_name: &'static str, pub(crate) point: &'static str, pub(crate) gamma: &'static str, - pub(crate) bytecode_ra_eval_prefix: &'static str, + pub(crate) bytecode_ra_eval_names_const: &'static str, + pub(crate) bytecode_ra_eval_family_const: &'static str, + pub(crate) bytecode_ra_eval_family_symbol: &'static str, + pub(crate) bytecode_ra_evals: &'static [&'static str], pub(crate) entries: &'static str, pub(crate) entry_bytecode_index: &'static str, pub(crate) stages_const: &'static str, @@ -281,7 +284,14 @@ const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { const_name: "STAGE6_BYTECODE_PLAN", point: "stage6.bytecode_read_raf.point", gamma: "stage6.bytecode_read_raf.gamma", - bytecode_ra_eval_prefix: "stage6.bytecode_read_raf.eval.BytecodeRa_", + bytecode_ra_eval_names_const: "STAGE6_BYTECODE_RA_EVAL_NAMES", + bytecode_ra_eval_family_const: "STAGE6_BYTECODE_RA_EVALS", + bytecode_ra_eval_family_symbol: "stage6.bytecode_read_raf.eval.BytecodeRa", + bytecode_ra_evals: &[ + "stage6.bytecode_read_raf.eval.BytecodeRa_0", + "stage6.bytecode_read_raf.eval.BytecodeRa_1", + "stage6.bytecode_read_raf.eval.BytecodeRa_2", + ], entries: "stage6.bytecode_read_raf.entries", entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", stages_const: "STAGE6_BYTECODE_STAGES", @@ -302,6 +312,28 @@ pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants() -> String { fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { let mut source = "\n".to_owned(); + push_format( + &mut source, + format_args!( + "#[rustfmt::skip]\nconst {}: &[&str] = &[{}];\n", + plan.bytecode_ra_eval_names_const, + plan.bytecode_ra_evals + .iter() + .map(|eval| rust_str(eval)) + .collect::>() + .join(", "), + ), + ); + push_format( + &mut source, + format_args!( + "const {}: bolt_verifier_runtime::NamedEvalFamilyPlan = bolt_verifier_runtime::NamedEvalFamilyPlan {{ symbol: {}, evals: {} }};\n\n", + plan.bytecode_ra_eval_family_const, + rust_str(plan.bytecode_ra_eval_family_symbol), + plan.bytecode_ra_eval_names_const, + ), + ); + for stage in plan.stages { push_format( &mut source, @@ -352,10 +384,10 @@ fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { push_format( &mut source, format_args!( - " point: {},\n gamma: {},\n bytecode_ra_eval_prefix: {},\n entries: {},\n entry_bytecode_index: {},\n stages: {},\n", + " point: {},\n gamma: {},\n bytecode_ra_evals: &{},\n entries: {},\n entry_bytecode_index: {},\n stages: {},\n", rust_str(plan.point), rust_str(plan.gamma), - rust_str(plan.bytecode_ra_eval_prefix), + plan.bytecode_ra_eval_family_const, rust_str(plan.entries), rust_str(plan.entry_bytecode_index), plan.stages_const, @@ -548,6 +580,10 @@ mod tests { assert!(source.contains("Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }")); assert!(source.contains("Stage67BytecodeFlag::IsInterleaved")); assert!(source.contains("Stage67BytecodeRegister::Rs2")); + assert!(source.contains("const STAGE6_BYTECODE_RA_EVAL_NAMES")); + assert!(source.contains( + "const STAGE6_BYTECODE_RA_EVALS: bolt_verifier_runtime::NamedEvalFamilyPlan" + )); assert!(source.contains("const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan")); } } diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 965bd3a077..a69e2d779b 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -29,8 +29,8 @@ use jolt_field::{Field, Fr, MulPow2}; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - field_powers, indexed_evals_by_prefix_any, prefix_point, store_point, store_scalar, - suffix_point, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, + eval_family_values, field_powers, prefix_point, store_point, store_scalar, suffix_point, + NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -90,7 +90,7 @@ pub struct Stage67RelationSymbols { pub struct Stage67BytecodeReadRafPlan { pub point: &'static str, pub gamma: &'static str, - pub bytecode_ra_eval_prefix: &'static str, + pub bytecode_ra_evals: &'static NamedEvalFamilyPlan, pub entries: &'static str, pub entry_bytecode_index: &'static str, pub stages: &'static [Stage67BytecodeStagePlan], @@ -240,7 +240,7 @@ pub fn evaluate_stage67_bytecode_read_raf( let entry_contrib = gamma_powers[plan.entry_contribution.gamma_power] * EqPolynomial::::mle(&entry_bits, r_address_prime) * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); - let bytecode_ra = indexed_evals_by_prefix_any(evals, plan.bytecode_ra_eval_prefix)? + let bytecode_ra = eval_family_values(evals, plan.bytecode_ra_evals)? .into_iter() .product::(); Ok((val + entry_contrib) * bytecode_ra) diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 965bd3a077..a69e2d779b 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -29,8 +29,8 @@ use jolt_field::{Field, Fr, MulPow2}; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - field_powers, indexed_evals_by_prefix_any, prefix_point, store_point, store_scalar, - suffix_point, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, + eval_family_values, field_powers, prefix_point, store_point, store_scalar, suffix_point, + NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -90,7 +90,7 @@ pub struct Stage67RelationSymbols { pub struct Stage67BytecodeReadRafPlan { pub point: &'static str, pub gamma: &'static str, - pub bytecode_ra_eval_prefix: &'static str, + pub bytecode_ra_evals: &'static NamedEvalFamilyPlan, pub entries: &'static str, pub entry_bytecode_index: &'static str, pub stages: &'static [Stage67BytecodeStagePlan], @@ -240,7 +240,7 @@ pub fn evaluate_stage67_bytecode_read_raf( let entry_contrib = gamma_powers[plan.entry_contribution.gamma_power] * EqPolynomial::::mle(&entry_bits, r_address_prime) * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); - let bytecode_ra = indexed_evals_by_prefix_any(evals, plan.bytecode_ra_eval_prefix)? + let bytecode_ra = eval_family_values(evals, plan.bytecode_ra_evals)? .into_iter() .product::(); Ok((val + entry_contrib) * bytecode_ra) diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 749464019f..79206d09cf 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, eval_by_name, find_batch, find_plan, indexed_evals_by_prefix_any, reverse_slice}; +use bolt_verifier_runtime::{batch_claims, eval_by_name, eval_family_values, find_batch, find_plan, reverse_slice, NamedEvalFamilyPlan}; use super::jolt_relations::{identity_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval}; use jolt_field::{Field, Fr}; use jolt_lookup_tables::LookupTableKind; @@ -194,6 +194,14 @@ pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[ Stage5SumcheckEvalPlan { symbol: "stage5.registers_val_evaluation.eval.RdWa", source: "stage5.sumcheck", name: "stage5.registers_val_evaluation.eval.RdWa", index: 1, oracle: "RdWa" }, ]; +#[rustfmt::skip] +pub const STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVAL_NAMES: &[&str] = &["stage5.instruction_read_raf.eval.LookupTableFlag_0", "stage5.instruction_read_raf.eval.LookupTableFlag_1", "stage5.instruction_read_raf.eval.LookupTableFlag_2", "stage5.instruction_read_raf.eval.LookupTableFlag_3", "stage5.instruction_read_raf.eval.LookupTableFlag_4", "stage5.instruction_read_raf.eval.LookupTableFlag_5", "stage5.instruction_read_raf.eval.LookupTableFlag_6", "stage5.instruction_read_raf.eval.LookupTableFlag_7", "stage5.instruction_read_raf.eval.LookupTableFlag_8", "stage5.instruction_read_raf.eval.LookupTableFlag_9", "stage5.instruction_read_raf.eval.LookupTableFlag_10", "stage5.instruction_read_raf.eval.LookupTableFlag_11", "stage5.instruction_read_raf.eval.LookupTableFlag_12", "stage5.instruction_read_raf.eval.LookupTableFlag_13", "stage5.instruction_read_raf.eval.LookupTableFlag_14", "stage5.instruction_read_raf.eval.LookupTableFlag_15", "stage5.instruction_read_raf.eval.LookupTableFlag_16", "stage5.instruction_read_raf.eval.LookupTableFlag_17", "stage5.instruction_read_raf.eval.LookupTableFlag_18", "stage5.instruction_read_raf.eval.LookupTableFlag_19", "stage5.instruction_read_raf.eval.LookupTableFlag_20", "stage5.instruction_read_raf.eval.LookupTableFlag_21", "stage5.instruction_read_raf.eval.LookupTableFlag_22", "stage5.instruction_read_raf.eval.LookupTableFlag_23", "stage5.instruction_read_raf.eval.LookupTableFlag_24", "stage5.instruction_read_raf.eval.LookupTableFlag_25", "stage5.instruction_read_raf.eval.LookupTableFlag_26", "stage5.instruction_read_raf.eval.LookupTableFlag_27", "stage5.instruction_read_raf.eval.LookupTableFlag_28", "stage5.instruction_read_raf.eval.LookupTableFlag_29", "stage5.instruction_read_raf.eval.LookupTableFlag_30", "stage5.instruction_read_raf.eval.LookupTableFlag_31", "stage5.instruction_read_raf.eval.LookupTableFlag_32", "stage5.instruction_read_raf.eval.LookupTableFlag_33", "stage5.instruction_read_raf.eval.LookupTableFlag_34", "stage5.instruction_read_raf.eval.LookupTableFlag_35", "stage5.instruction_read_raf.eval.LookupTableFlag_36", "stage5.instruction_read_raf.eval.LookupTableFlag_37", "stage5.instruction_read_raf.eval.LookupTableFlag_38", "stage5.instruction_read_raf.eval.LookupTableFlag_39", "stage5.instruction_read_raf.eval.LookupTableFlag_40"]; +pub const STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS: NamedEvalFamilyPlan = NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.LookupTableFlag", evals: STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVAL_NAMES }; + +#[rustfmt::skip] +pub const STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES: &[&str] = &["stage5.instruction_read_raf.eval.InstructionRa_0", "stage5.instruction_read_raf.eval.InstructionRa_1", "stage5.instruction_read_raf.eval.InstructionRa_2", "stage5.instruction_read_raf.eval.InstructionRa_3", "stage5.instruction_read_raf.eval.InstructionRa_4", "stage5.instruction_read_raf.eval.InstructionRa_5", "stage5.instruction_read_raf.eval.InstructionRa_6", "stage5.instruction_read_raf.eval.InstructionRa_7"]; +pub const STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS: NamedEvalFamilyPlan = NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.InstructionRa", evals: STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES }; + pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[ Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.Cycle", source: "stage5.instruction_read_raf.instance", offset: 128, length: 16, input: "stage5.instruction_read_raf.instance" }, Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0.address", source: "stage5.instruction_read_raf.instance", offset: 0, length: 16, input: "stage5.instruction_read_raf.instance" }, @@ -651,10 +659,8 @@ fn expected_instruction_read_raf( let right_operand_eval = operand_polynomial_eval(r_address_prime, false); let identity_poly_eval = identity_polynomial_eval(r_address_prime); - let table_flag_claims = indexed_evals_by_prefix_any( - evals, - "stage5.instruction_read_raf.eval.LookupTableFlag_", - )?; + let table_flag_claims = + eval_family_values(evals, &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS)?; let table_values = LookupTableKind::::all() .iter() .take(table_flag_claims.len()) @@ -666,9 +672,9 @@ fn expected_instruction_read_raf( .map(|(table_value, flag_claim)| table_value * flag_claim) .sum::(); - let ra_claim = indexed_evals_by_prefix_any( + let ra_claim = eval_family_values( evals, - "stage5.instruction_read_raf.eval.InstructionRa_", + &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS, )? .into_iter() .product::(); diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 0c86981a27..d2a967827a 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -99,6 +99,10 @@ const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { hamming_booleanity_instance: "stage6.hamming_booleanity.instance", }; +#[rustfmt::skip] +const STAGE6_BYTECODE_RA_EVAL_NAMES: &[&str] = &["stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"]; +const STAGE6_BYTECODE_RA_EVALS: bolt_verifier_runtime::NamedEvalFamilyPlan = bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage6.bytecode_read_raf.eval.BytecodeRa", evals: STAGE6_BYTECODE_RA_EVAL_NAMES }; + const STAGE6_BYTECODE_STAGE1_TERMS: &[Stage67BytecodeTermPlan] = &[ Stage67BytecodeTermPlan::Address { gamma_power: 0 }, Stage67BytecodeTermPlan::Imm { gamma_power: 1 }, @@ -155,7 +159,7 @@ const STAGE6_BYTECODE_STAGES: &[Stage67BytecodeStagePlan] = &[ const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { point: "stage6.bytecode_read_raf.point", gamma: "stage6.bytecode_read_raf.gamma", - bytecode_ra_eval_prefix: "stage6.bytecode_read_raf.eval.BytecodeRa_", + bytecode_ra_evals: &STAGE6_BYTECODE_RA_EVALS, entries: "stage6.bytecode_read_raf.entries", entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", stages: STAGE6_BYTECODE_STAGES, From 048f07860536716b2f8d37bd21b86918aaf1cdd3 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 23:49:56 -0600 Subject: [PATCH 052/171] refactor(bolt): plan stage5 instruction read raf output --- .../src/protocols/jolt/emit/rust/stage5.rs | 80 +++++-------------- .../jolt/verifier_jolt_relations.rs.template | 66 ++++++++++++++- .../src/stages/jolt_relations.rs | 66 ++++++++++++++- crates/jolt-verifier/src/stages/stage5.rs | 79 +++++------------- 4 files changed, 165 insertions(+), 126 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index ff850b688a..08d2881f36 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1080,11 +1080,9 @@ impl Stage5CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, eval_by_name, eval_family_values, find_batch, find_plan, reverse_slice, NamedEvalFamilyPlan};\n\ - use super::jolt_relations::{identity_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval};\n\ + "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan, NamedEvalFamilyPlan};\n\ + use super::jolt_relations::{evaluate_stage5_instruction_read_raf, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan};\n\ use jolt_field::{Field, Fr};\n\ - use jolt_lookup_tables::LookupTableKind;\n\ - use jolt_poly::EqPolynomial;\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" } @@ -1907,6 +1905,17 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); ), ); } + source.push_str( + "pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan {\n\ + \x20 point: \"stage5.instruction_read_raf.point\",\n\ + \x20 lookup_output_point: \"stage5.input.stage2.instruction.LookupOutput\",\n\ + \x20 table_flag_evals: &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS,\n\ + \x20 instruction_ra_evals: &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS,\n\ + \x20 raf_flag_eval: \"stage5.instruction_read_raf.eval.InstructionRafFlag\",\n\ + \x20 gamma: \"stage5.instruction_read_raf.gamma\",\n\ + \x20 log_k: 128,\n\ + };\n\n", + ); Ok(source) } @@ -2417,7 +2426,12 @@ fn expected_batched_output_claim( }; let value = match relation { Stage5RelationKind::Stage5InstructionReadRaf => { - expected_instruction_read_raf(store, evals, local_point)? + evaluate_stage5_instruction_read_raf( + &STAGE5_INSTRUCTION_READ_RAF_PLAN, + store, + evals, + local_point, + )? } Stage5RelationKind::Stage5RamRaClaimReduction => { let output_claim = program @@ -2460,62 +2474,6 @@ fn expected_batched_output_claim( Ok(expected) } -fn expected_instruction_read_raf( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage5NamedEval], - local_point: &[Fr], -) -> Result { - const LOG_K: usize = 128; - const XLEN: usize = 64; - - if local_point.len() < LOG_K { - return Err(VerifyStage5Error::InvalidInputLength { - input: "stage5.instruction_read_raf.point", - expected: LOG_K, - actual: local_point.len(), - }); - } - - let (r_address_prime, r_cycle) = local_point.split_at(LOG_K); - let r_cycle_prime = reverse_slice(r_cycle); - let r_reduction = bolt_verifier_runtime::store_point(store, "stage5.input.stage2.instruction.LookupOutput")?; - let eq_eval_r_reduction = EqPolynomial::::mle(r_reduction, &r_cycle_prime); - - let left_operand_eval = operand_polynomial_eval(r_address_prime, true); - let right_operand_eval = operand_polynomial_eval(r_address_prime, false); - let identity_poly_eval = identity_polynomial_eval(r_address_prime); - - let table_flag_claims = - eval_family_values(evals, &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS)?; - let table_values = LookupTableKind::::all() - .iter() - .take(table_flag_claims.len()) - .map(|table| table.evaluate_mle::(r_address_prime)) - .collect::>(); - let val_claim = table_values - .into_iter() - .zip(table_flag_claims) - .map(|(table_value, flag_claim)| table_value * flag_claim) - .sum::(); - - let ra_claim = eval_family_values( - evals, - &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS, - )? - .into_iter() - .product::(); - let raf_flag_claim = eval_by_name( - evals, - "stage5.instruction_read_raf.eval.InstructionRafFlag", - )?; - let gamma = bolt_verifier_runtime::store_scalar(store, "stage5.instruction_read_raf.gamma")?; - - let raf_claim = (Fr::from_u64(1) - raf_flag_claim) - * (left_operand_eval + gamma * right_operand_eval) - + raf_flag_claim * gamma * identity_poly_eval; - Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim)) -} - "# } } diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index a69e2d779b..971cf1019d 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -26,11 +26,13 @@ //! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition. use jolt_field::{Field, Fr, MulPow2}; +use jolt_lookup_tables::LookupTableKind; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - eval_family_values, field_powers, prefix_point, store_point, store_scalar, suffix_point, - NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, + eval_by_name, eval_family_values, field_powers, prefix_point, reverse_slice, store_point, + store_scalar, suffix_point, NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, + SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -86,6 +88,17 @@ pub struct Stage67RelationSymbols { pub hamming_booleanity_instance: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage5InstructionReadRafPlan { + pub point: &'static str, + pub lookup_output_point: &'static str, + pub table_flag_evals: &'static NamedEvalFamilyPlan, + pub instruction_ra_evals: &'static NamedEvalFamilyPlan, + pub raf_flag_eval: &'static str, + pub gamma: &'static str, + pub log_k: usize, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage67BytecodeReadRafPlan { pub point: &'static str, @@ -182,6 +195,55 @@ pub trait Stage67BytecodeEntry { fn is_noop(&self) -> bool; } +pub fn evaluate_stage5_instruction_read_raf( + plan: &Stage5InstructionReadRafPlan, + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], +) -> Result { + const XLEN: usize = 64; + + if local_point.len() < plan.log_k { + return Err(RuntimePlanError::InvalidInputLength { + input: plan.point, + expected: plan.log_k, + actual: local_point.len(), + }); + } + + let (r_address_prime, r_cycle) = local_point.split_at(plan.log_k); + let r_cycle_prime = reverse_slice(r_cycle); + let r_reduction = store_point(store, plan.lookup_output_point)?; + let eq_eval_r_reduction = EqPolynomial::::mle(r_reduction, &r_cycle_prime); + + let left_operand_eval = operand_polynomial_eval(r_address_prime, true); + let right_operand_eval = operand_polynomial_eval(r_address_prime, false); + let identity_poly_eval = identity_polynomial_eval(r_address_prime); + + let table_flag_claims = eval_family_values(evals, plan.table_flag_evals)?; + let table_values = LookupTableKind::::all() + .iter() + .take(table_flag_claims.len()) + .map(|table| table.evaluate_mle::(r_address_prime)) + .collect::>(); + let val_claim = table_values + .into_iter() + .zip(table_flag_claims) + .map(|(table_value, flag_claim)| table_value * flag_claim) + .sum::(); + + let ra_claim = eval_family_values(evals, plan.instruction_ra_evals)? + .into_iter() + .product::(); + let raf_flag_claim = eval_by_name(evals, plan.raf_flag_eval)?; + let gamma = store_scalar(store, plan.gamma)?; + + let raf_claim = (Fr::from_u64(1) - raf_flag_claim) + * (left_operand_eval + gamma * right_operand_eval) + + raf_flag_claim * gamma * identity_poly_eval; + Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim)) +} + pub fn stage67_trace_rounds( instance_results: &[SumcheckInstanceResultPlan], symbols: &Stage67RelationSymbols, diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index a69e2d779b..971cf1019d 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -26,11 +26,13 @@ //! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition. use jolt_field::{Field, Fr, MulPow2}; +use jolt_lookup_tables::LookupTableKind; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - eval_family_values, field_powers, prefix_point, store_point, store_scalar, suffix_point, - NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, + eval_by_name, eval_family_values, field_powers, prefix_point, reverse_slice, store_point, + store_scalar, suffix_point, NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, + SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -86,6 +88,17 @@ pub struct Stage67RelationSymbols { pub hamming_booleanity_instance: &'static str, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage5InstructionReadRafPlan { + pub point: &'static str, + pub lookup_output_point: &'static str, + pub table_flag_evals: &'static NamedEvalFamilyPlan, + pub instruction_ra_evals: &'static NamedEvalFamilyPlan, + pub raf_flag_eval: &'static str, + pub gamma: &'static str, + pub log_k: usize, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage67BytecodeReadRafPlan { pub point: &'static str, @@ -182,6 +195,55 @@ pub trait Stage67BytecodeEntry { fn is_noop(&self) -> bool; } +pub fn evaluate_stage5_instruction_read_raf( + plan: &Stage5InstructionReadRafPlan, + store: &ValueStore, + evals: &[StageNamedEval], + local_point: &[Fr], +) -> Result { + const XLEN: usize = 64; + + if local_point.len() < plan.log_k { + return Err(RuntimePlanError::InvalidInputLength { + input: plan.point, + expected: plan.log_k, + actual: local_point.len(), + }); + } + + let (r_address_prime, r_cycle) = local_point.split_at(plan.log_k); + let r_cycle_prime = reverse_slice(r_cycle); + let r_reduction = store_point(store, plan.lookup_output_point)?; + let eq_eval_r_reduction = EqPolynomial::::mle(r_reduction, &r_cycle_prime); + + let left_operand_eval = operand_polynomial_eval(r_address_prime, true); + let right_operand_eval = operand_polynomial_eval(r_address_prime, false); + let identity_poly_eval = identity_polynomial_eval(r_address_prime); + + let table_flag_claims = eval_family_values(evals, plan.table_flag_evals)?; + let table_values = LookupTableKind::::all() + .iter() + .take(table_flag_claims.len()) + .map(|table| table.evaluate_mle::(r_address_prime)) + .collect::>(); + let val_claim = table_values + .into_iter() + .zip(table_flag_claims) + .map(|(table_value, flag_claim)| table_value * flag_claim) + .sum::(); + + let ra_claim = eval_family_values(evals, plan.instruction_ra_evals)? + .into_iter() + .product::(); + let raf_flag_claim = eval_by_name(evals, plan.raf_flag_eval)?; + let gamma = store_scalar(store, plan.gamma)?; + + let raf_claim = (Fr::from_u64(1) - raf_flag_claim) + * (left_operand_eval + gamma * right_operand_eval) + + raf_flag_claim * gamma * identity_poly_eval; + Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim)) +} + pub fn stage67_trace_rounds( instance_results: &[SumcheckInstanceResultPlan], symbols: &Stage67RelationSymbols, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 79206d09cf..e770635cea 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,10 +1,8 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, eval_by_name, eval_family_values, find_batch, find_plan, reverse_slice, NamedEvalFamilyPlan}; -use super::jolt_relations::{identity_polynomial_eval, normalize_instruction_read_raf_point, operand_polynomial_eval}; +use bolt_verifier_runtime::{batch_claims, find_batch, find_plan, NamedEvalFamilyPlan}; +use super::jolt_relations::{evaluate_stage5_instruction_read_raf, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan}; use jolt_field::{Field, Fr}; -use jolt_lookup_tables::LookupTableKind; -use jolt_poly::EqPolynomial; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -202,6 +200,16 @@ pub const STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS: NamedEvalFamilyPlan = Na pub const STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES: &[&str] = &["stage5.instruction_read_raf.eval.InstructionRa_0", "stage5.instruction_read_raf.eval.InstructionRa_1", "stage5.instruction_read_raf.eval.InstructionRa_2", "stage5.instruction_read_raf.eval.InstructionRa_3", "stage5.instruction_read_raf.eval.InstructionRa_4", "stage5.instruction_read_raf.eval.InstructionRa_5", "stage5.instruction_read_raf.eval.InstructionRa_6", "stage5.instruction_read_raf.eval.InstructionRa_7"]; pub const STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS: NamedEvalFamilyPlan = NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.InstructionRa", evals: STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES }; +pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan { + point: "stage5.instruction_read_raf.point", + lookup_output_point: "stage5.input.stage2.instruction.LookupOutput", + table_flag_evals: &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS, + instruction_ra_evals: &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS, + raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag", + gamma: "stage5.instruction_read_raf.gamma", + log_k: 128, +}; + pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[ Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.Cycle", source: "stage5.instruction_read_raf.instance", offset: 128, length: 16, input: "stage5.instruction_read_raf.instance" }, Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0.address", source: "stage5.instruction_read_raf.instance", offset: 0, length: 16, input: "stage5.instruction_read_raf.instance" }, @@ -591,7 +599,12 @@ fn expected_batched_output_claim( }; let value = match relation { Stage5RelationKind::Stage5InstructionReadRaf => { - expected_instruction_read_raf(store, evals, local_point)? + evaluate_stage5_instruction_read_raf( + &STAGE5_INSTRUCTION_READ_RAF_PLAN, + store, + evals, + local_point, + )? } Stage5RelationKind::Stage5RamRaClaimReduction => { let output_claim = program @@ -633,59 +646,3 @@ fn expected_batched_output_claim( } Ok(expected) } - -fn expected_instruction_read_raf( - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage5NamedEval], - local_point: &[Fr], -) -> Result { - const LOG_K: usize = 128; - const XLEN: usize = 64; - - if local_point.len() < LOG_K { - return Err(VerifyStage5Error::InvalidInputLength { - input: "stage5.instruction_read_raf.point", - expected: LOG_K, - actual: local_point.len(), - }); - } - - let (r_address_prime, r_cycle) = local_point.split_at(LOG_K); - let r_cycle_prime = reverse_slice(r_cycle); - let r_reduction = bolt_verifier_runtime::store_point(store, "stage5.input.stage2.instruction.LookupOutput")?; - let eq_eval_r_reduction = EqPolynomial::::mle(r_reduction, &r_cycle_prime); - - let left_operand_eval = operand_polynomial_eval(r_address_prime, true); - let right_operand_eval = operand_polynomial_eval(r_address_prime, false); - let identity_poly_eval = identity_polynomial_eval(r_address_prime); - - let table_flag_claims = - eval_family_values(evals, &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS)?; - let table_values = LookupTableKind::::all() - .iter() - .take(table_flag_claims.len()) - .map(|table| table.evaluate_mle::(r_address_prime)) - .collect::>(); - let val_claim = table_values - .into_iter() - .zip(table_flag_claims) - .map(|(table_value, flag_claim)| table_value * flag_claim) - .sum::(); - - let ra_claim = eval_family_values( - evals, - &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS, - )? - .into_iter() - .product::(); - let raf_flag_claim = eval_by_name( - evals, - "stage5.instruction_read_raf.eval.InstructionRafFlag", - )?; - let gamma = bolt_verifier_runtime::store_scalar(store, "stage5.instruction_read_raf.gamma")?; - - let raf_claim = (Fr::from_u64(1) - raf_flag_claim) - * (left_operand_eval + gamma * right_operand_eval) - + raf_flag_claim * gamma * identity_poly_eval; - Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim)) -} From 6c0a281b55e72c7c701a8243b6f77912b08258e5 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Thu, 14 May 2026 23:53:19 -0600 Subject: [PATCH 053/171] refactor(bolt): reuse indexed eq in bytecode raf --- .../jolt/verifier_jolt_relations.rs.template | 13 +++++++++---- crates/jolt-verifier/src/stages/jolt_relations.rs | 13 +++++++++---- 2 files changed, 18 insertions(+), 8 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 971cf1019d..2d152d2a41 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -295,12 +295,17 @@ pub fn evaluate_stage67_bytecode_read_raf( * gamma_powers[stage.output_gamma_power]; } - let entry_bits = (0..log_k) - .map(|index| Fr::from_u64(((entry_bytecode_index >> (log_k - 1 - index)) & 1) as u64)) - .collect::>(); + let entry_address_eq = + EqPolynomial::::try_mle_at_boolean_index(entry_bytecode_index, r_address_prime).ok_or( + RuntimePlanError::InvalidInputLength { + input: plan.entry_bytecode_index, + expected: 1usize.checked_shl(log_k as u32).unwrap_or(usize::MAX), + actual: entry_bytecode_index.saturating_add(1), + }, + )?; let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; let entry_contrib = gamma_powers[plan.entry_contribution.gamma_power] - * EqPolynomial::::mle(&entry_bits, r_address_prime) + * entry_address_eq * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); let bytecode_ra = eval_family_values(evals, plan.bytecode_ra_evals)? .into_iter() diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 971cf1019d..2d152d2a41 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -295,12 +295,17 @@ pub fn evaluate_stage67_bytecode_read_raf( * gamma_powers[stage.output_gamma_power]; } - let entry_bits = (0..log_k) - .map(|index| Fr::from_u64(((entry_bytecode_index >> (log_k - 1 - index)) & 1) as u64)) - .collect::>(); + let entry_address_eq = + EqPolynomial::::try_mle_at_boolean_index(entry_bytecode_index, r_address_prime).ok_or( + RuntimePlanError::InvalidInputLength { + input: plan.entry_bytecode_index, + expected: 1usize.checked_shl(log_k as u32).unwrap_or(usize::MAX), + actual: entry_bytecode_index.saturating_add(1), + }, + )?; let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; let entry_contrib = gamma_powers[plan.entry_contribution.gamma_power] - * EqPolynomial::::mle(&entry_bits, r_address_prime) + * entry_address_eq * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); let bytecode_ra = eval_family_values(evals, plan.bytecode_ra_evals)? .into_iter() From f644ff9894b9d85e34832afff2609422b44a93e4 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 00:01:28 -0600 Subject: [PATCH 054/171] refactor(bolt): plan bytecode raf output terms --- .../src/protocols/jolt/emit/rust/stage6.rs | 2 +- .../jolt/stage6_bytecode_read_raf_plan.rs | 125 +++++++++++++----- .../jolt/verifier_jolt_relations.rs.template | 102 ++++++++++---- .../src/stages/jolt_relations.rs | 102 ++++++++++---- crates/jolt-verifier/src/stages/stage6.rs | 23 +++- 5 files changed, 264 insertions(+), 90 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 009a20a0a1..4b62f540ab 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1161,7 +1161,7 @@ impl Stage6CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ - use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeEntryContributionPlan, Stage67BytecodeFlag, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\ + use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 0ae285a8b4..ff4e693b26 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -13,7 +13,8 @@ pub(crate) struct BytecodeReadRafPlan { pub(crate) entry_bytecode_index: &'static str, pub(crate) stages_const: &'static str, pub(crate) stages: &'static [BytecodeReadRafStagePlan], - pub(crate) entry_contribution: BytecodeEntryContributionPlan, + pub(crate) output_terms_const: &'static str, + pub(crate) output_terms: &'static [BytecodeOutputTermPlan], pub(crate) registers: BytecodeRegisterSymbols, pub(crate) entry_lookup_table: &'static str, } @@ -24,14 +25,19 @@ pub(crate) struct BytecodeReadRafStagePlan { pub(crate) gamma: &'static str, pub(crate) cycle_point: &'static str, pub(crate) register_point: Option<&'static str>, - pub(crate) output_gamma_power: usize, - pub(crate) identity_gamma_power: Option, pub(crate) terms: &'static [BytecodeReadRafTermPlan], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) struct BytecodeEntryContributionPlan { - pub(crate) gamma_power: usize, +pub(crate) enum BytecodeOutputTermPlan { + StageValue { + stage_index: usize, + gamma_power: usize, + identity_gamma_power: Option, + }, + Entry { + gamma_power: usize, + }, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -238,8 +244,6 @@ const STAGE6_BYTECODE_STAGES: &[BytecodeReadRafStagePlan] = &[ gamma: "stage6.bytecode_read_raf.stage1_gamma", cycle_point: "stage6.input.stage1.Imm", register_point: None, - output_gamma_power: 0, - identity_gamma_power: Some(5), terms: STAGE6_BYTECODE_STAGE1_TERMS, }, BytecodeReadRafStagePlan { @@ -247,8 +251,6 @@ const STAGE6_BYTECODE_STAGES: &[BytecodeReadRafStagePlan] = &[ gamma: "stage6.bytecode_read_raf.stage2_gamma", cycle_point: "stage6.input.stage2.OpFlagJump", register_point: None, - output_gamma_power: 1, - identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE2_TERMS, }, BytecodeReadRafStagePlan { @@ -256,8 +258,6 @@ const STAGE6_BYTECODE_STAGES: &[BytecodeReadRafStagePlan] = &[ gamma: "stage6.bytecode_read_raf.stage3_gamma", cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC", register_point: None, - output_gamma_power: 2, - identity_gamma_power: Some(4), terms: STAGE6_BYTECODE_STAGE3_TERMS, }, BytecodeReadRafStagePlan { @@ -265,8 +265,6 @@ const STAGE6_BYTECODE_STAGES: &[BytecodeReadRafStagePlan] = &[ gamma: "stage6.bytecode_read_raf.stage4_gamma", cycle_point: "stage6.input.stage4.Rs1Ra", register_point: Some("stage6.input.stage4.Rs1Ra"), - output_gamma_power: 3, - identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE4_TERMS, }, BytecodeReadRafStagePlan { @@ -274,12 +272,39 @@ const STAGE6_BYTECODE_STAGES: &[BytecodeReadRafStagePlan] = &[ gamma: "stage6.bytecode_read_raf.stage5_gamma", cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa", register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"), - output_gamma_power: 4, - identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE5_TERMS, }, ]; +const STAGE6_BYTECODE_OUTPUT_TERMS: &[BytecodeOutputTermPlan] = &[ + BytecodeOutputTermPlan::StageValue { + stage_index: 0, + gamma_power: 0, + identity_gamma_power: Some(5), + }, + BytecodeOutputTermPlan::StageValue { + stage_index: 1, + gamma_power: 1, + identity_gamma_power: None, + }, + BytecodeOutputTermPlan::StageValue { + stage_index: 2, + gamma_power: 2, + identity_gamma_power: Some(4), + }, + BytecodeOutputTermPlan::StageValue { + stage_index: 3, + gamma_power: 3, + identity_gamma_power: None, + }, + BytecodeOutputTermPlan::StageValue { + stage_index: 4, + gamma_power: 4, + identity_gamma_power: None, + }, + BytecodeOutputTermPlan::Entry { gamma_power: 7 }, +]; + const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { const_name: "STAGE6_BYTECODE_PLAN", point: "stage6.bytecode_read_raf.point", @@ -296,7 +321,8 @@ const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", stages_const: "STAGE6_BYTECODE_STAGES", stages: STAGE6_BYTECODE_STAGES, - entry_contribution: BytecodeEntryContributionPlan { gamma_power: 7 }, + output_terms_const: "STAGE6_BYTECODE_OUTPUT_TERMS", + output_terms: STAGE6_BYTECODE_OUTPUT_TERMS, registers: BytecodeRegisterSymbols { rd: "stage6.bytecode.entry.rd", rs1: "stage6.bytecode.entry.rs1", @@ -362,18 +388,31 @@ fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { push_format( &mut source, format_args!( - " Stage67BytecodeStagePlan {{ gamma: {}, cycle_point: {}, register_point: {}, output_gamma_power: {}, identity_gamma_power: {}, terms: {} }},\n", + " Stage67BytecodeStagePlan {{ gamma: {}, cycle_point: {}, register_point: {}, terms: {} }},\n", rust_str(stage.gamma), rust_str(stage.cycle_point), rust_option_str(stage.register_point), - stage.output_gamma_power, - emit_option_usize(stage.identity_gamma_power), stage.terms_const, ), ); } source.push_str("];\n\n"); + push_format( + &mut source, + format_args!( + "const {}: &[Stage67BytecodeOutputTermPlan] = &[\n", + plan.output_terms_const + ), + ); + for term in plan.output_terms { + push_format( + &mut source, + format_args!(" {},\n", emit_bytecode_output_term_plan(term)), + ); + } + source.push_str("];\n\n"); + push_format( &mut source, format_args!( @@ -384,20 +423,14 @@ fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { push_format( &mut source, format_args!( - " point: {},\n gamma: {},\n bytecode_ra_evals: &{},\n entries: {},\n entry_bytecode_index: {},\n stages: {},\n", + " point: {},\n gamma: {},\n bytecode_ra_evals: &{},\n entries: {},\n entry_bytecode_index: {},\n stages: {},\n output_terms: {},\n", rust_str(plan.point), rust_str(plan.gamma), plan.bytecode_ra_eval_family_const, rust_str(plan.entries), rust_str(plan.entry_bytecode_index), plan.stages_const, - ), - ); - push_format( - &mut source, - format_args!( - " entry_contribution: Stage67BytecodeEntryContributionPlan {{ gamma_power: {} }},\n", - plan.entry_contribution.gamma_power + plan.output_terms_const, ), ); source.push_str(" registers: Stage67BytecodeRegisterSymbols {\n"); @@ -454,6 +487,22 @@ fn emit_bytecode_read_raf_term_plan(term: &BytecodeReadRafTermPlan) -> String { } } +fn emit_bytecode_output_term_plan(term: &BytecodeOutputTermPlan) -> String { + match *term { + BytecodeOutputTermPlan::StageValue { + stage_index, + gamma_power, + identity_gamma_power, + } => format!( + "Stage67BytecodeOutputTermPlan::StageValue {{ stage_index: {stage_index}, gamma_power: {gamma_power}, identity_gamma_power: {} }}", + emit_option_usize(identity_gamma_power), + ), + BytecodeOutputTermPlan::Entry { gamma_power } => { + format!("Stage67BytecodeOutputTermPlan::Entry {{ gamma_power: {gamma_power} }}") + } + } +} + fn emit_bytecode_flag(flag: BytecodeFlag) -> &'static str { match flag { BytecodeFlag::IsInterleaved => "Stage67BytecodeFlag::IsInterleaved", @@ -492,8 +541,8 @@ fn rust_option_str(value: Option<&str>) -> String { #[cfg(test)] mod tests { use super::{ - emit_stage6_bytecode_read_raf_plan_constants, BytecodeFlag, BytecodeReadRafTermPlan, - BytecodeRegister, STAGE6_BYTECODE_READ_RAF_PLAN, + emit_stage6_bytecode_read_raf_plan_constants, BytecodeFlag, BytecodeOutputTermPlan, + BytecodeReadRafTermPlan, BytecodeRegister, STAGE6_BYTECODE_READ_RAF_PLAN, }; #[test] @@ -501,7 +550,7 @@ mod tests { let plan = &STAGE6_BYTECODE_READ_RAF_PLAN; assert_eq!(plan.stages.len(), 5); - assert_eq!(plan.entry_contribution.gamma_power, 7); + assert_eq!(plan.output_terms.len(), 6); assert_eq!(plan.registers.rd, "stage6.bytecode.entry.rd"); assert_eq!( plan.entry_lookup_table, @@ -509,9 +558,19 @@ mod tests { ); let stage1 = &plan.stages[0]; - assert_eq!(stage1.output_gamma_power, 0); - assert_eq!(stage1.identity_gamma_power, Some(5)); assert_eq!(stage1.terms.len(), 16); + assert_eq!( + plan.output_terms[0], + BytecodeOutputTermPlan::StageValue { + stage_index: 0, + gamma_power: 0, + identity_gamma_power: Some(5), + } + ); + assert_eq!( + plan.output_terms[5], + BytecodeOutputTermPlan::Entry { gamma_power: 7 } + ); assert_eq!( stage1.terms[0], BytecodeReadRafTermPlan::Address { gamma_power: 0 } @@ -584,6 +643,8 @@ mod tests { assert!(source.contains( "const STAGE6_BYTECODE_RA_EVALS: bolt_verifier_runtime::NamedEvalFamilyPlan" )); + assert!(source.contains("const STAGE6_BYTECODE_OUTPUT_TERMS")); + assert!(source.contains("Stage67BytecodeOutputTermPlan::Entry { gamma_power: 7 }")); assert!(source.contains("const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan")); } } diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 2d152d2a41..07d01a524e 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -107,7 +107,7 @@ pub struct Stage67BytecodeReadRafPlan { pub entries: &'static str, pub entry_bytecode_index: &'static str, pub stages: &'static [Stage67BytecodeStagePlan], - pub entry_contribution: Stage67BytecodeEntryContributionPlan, + pub output_terms: &'static [Stage67BytecodeOutputTermPlan], pub registers: Stage67BytecodeRegisterSymbols, pub entry_lookup_table: &'static str, } @@ -117,14 +117,19 @@ pub struct Stage67BytecodeStagePlan { pub gamma: &'static str, pub cycle_point: &'static str, pub register_point: Option<&'static str>, - pub output_gamma_power: usize, - pub identity_gamma_power: Option, pub terms: &'static [Stage67BytecodeTermPlan], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage67BytecodeEntryContributionPlan { - pub gamma_power: usize, +pub enum Stage67BytecodeOutputTermPlan { + StageValue { + stage_index: usize, + gamma_power: usize, + identity_gamma_power: Option, + }, + Entry { + gamma_power: usize, + }, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -273,7 +278,6 @@ pub fn evaluate_stage67_bytecode_read_raf( let gamma = store_scalar(store, plan.gamma)?; let gamma_powers = bytecode_gamma_powers(gamma); - let int_eval = identity_polynomial_eval(r_address_prime); let stage_value_evals = stage67_bytecode_stage_value_evals( plan, entries, @@ -283,18 +287,34 @@ pub fn evaluate_stage67_bytecode_read_raf( r_address_prime, r_cycle_prime.len(), )?; + let output_contrib = stage67_bytecode_output_contribution( + plan, + store, + &stage_value_evals, + &gamma_powers, + entry_bytecode_index, + r_address_prime, + r_cycle_prime, + log_k, + )?; + let bytecode_ra = eval_family_values(evals, plan.bytecode_ra_evals)? + .into_iter() + .product::(); + Ok(output_contrib * bytecode_ra) +} - let mut val = Fr::from_u64(0); - for (index, stage) in plan.stages.iter().enumerate() { - let cycle_point = stage67_bytecode_stage_cycle_point(store, stage, r_cycle_prime.len())?; - let int_contrib = stage - .identity_gamma_power - .map_or(Fr::from_u64(0), |power| gamma_powers[power] * int_eval); - val += (stage_value_evals[index] + int_contrib) - * EqPolynomial::::mle(&cycle_point, r_cycle_prime) - * gamma_powers[stage.output_gamma_power]; - } - +fn stage67_bytecode_output_contribution( + plan: &Stage67BytecodeReadRafPlan, + store: &ValueStore, + stage_value_evals: &[Fr], + gamma_powers: &[Fr], + entry_bytecode_index: usize, + r_address_prime: &[Fr], + r_cycle_prime: &[Fr], + log_k: usize, +) -> Result { + let int_eval = identity_polynomial_eval(r_address_prime); + let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; let entry_address_eq = EqPolynomial::::try_mle_at_boolean_index(entry_bytecode_index, r_address_prime).ok_or( RuntimePlanError::InvalidInputLength { @@ -303,14 +323,46 @@ pub fn evaluate_stage67_bytecode_read_raf( actual: entry_bytecode_index.saturating_add(1), }, )?; - let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; - let entry_contrib = gamma_powers[plan.entry_contribution.gamma_power] - * entry_address_eq - * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); - let bytecode_ra = eval_family_values(evals, plan.bytecode_ra_evals)? - .into_iter() - .product::(); - Ok((val + entry_contrib) * bytecode_ra) + + let mut output = Fr::from_u64(0); + for term in plan.output_terms { + output += match *term { + Stage67BytecodeOutputTermPlan::StageValue { + stage_index, + gamma_power, + identity_gamma_power, + } => { + let stage = + plan.stages + .get(stage_index) + .ok_or(RuntimePlanError::InvalidInputLength { + input: plan.entries, + expected: stage_index + 1, + actual: plan.stages.len(), + })?; + let value = stage_value_evals.get(stage_index).copied().ok_or( + RuntimePlanError::InvalidInputLength { + input: plan.entries, + expected: stage_index + 1, + actual: stage_value_evals.len(), + }, + )?; + let cycle_point = + stage67_bytecode_stage_cycle_point(store, stage, r_cycle_prime.len())?; + let identity_contrib = identity_gamma_power + .map_or(Fr::from_u64(0), |power| gamma_powers[power] * int_eval); + (value + identity_contrib) + * EqPolynomial::::mle(&cycle_point, r_cycle_prime) + * gamma_powers[gamma_power] + } + Stage67BytecodeOutputTermPlan::Entry { gamma_power } => { + gamma_powers[gamma_power] + * entry_address_eq + * EqPolynomial::::mle(&zero_cycle, r_cycle_prime) + } + }; + } + Ok(output) } fn stage67_bytecode_stage_cycle_point( diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 2d152d2a41..07d01a524e 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -107,7 +107,7 @@ pub struct Stage67BytecodeReadRafPlan { pub entries: &'static str, pub entry_bytecode_index: &'static str, pub stages: &'static [Stage67BytecodeStagePlan], - pub entry_contribution: Stage67BytecodeEntryContributionPlan, + pub output_terms: &'static [Stage67BytecodeOutputTermPlan], pub registers: Stage67BytecodeRegisterSymbols, pub entry_lookup_table: &'static str, } @@ -117,14 +117,19 @@ pub struct Stage67BytecodeStagePlan { pub gamma: &'static str, pub cycle_point: &'static str, pub register_point: Option<&'static str>, - pub output_gamma_power: usize, - pub identity_gamma_power: Option, pub terms: &'static [Stage67BytecodeTermPlan], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage67BytecodeEntryContributionPlan { - pub gamma_power: usize, +pub enum Stage67BytecodeOutputTermPlan { + StageValue { + stage_index: usize, + gamma_power: usize, + identity_gamma_power: Option, + }, + Entry { + gamma_power: usize, + }, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -273,7 +278,6 @@ pub fn evaluate_stage67_bytecode_read_raf( let gamma = store_scalar(store, plan.gamma)?; let gamma_powers = bytecode_gamma_powers(gamma); - let int_eval = identity_polynomial_eval(r_address_prime); let stage_value_evals = stage67_bytecode_stage_value_evals( plan, entries, @@ -283,18 +287,34 @@ pub fn evaluate_stage67_bytecode_read_raf( r_address_prime, r_cycle_prime.len(), )?; + let output_contrib = stage67_bytecode_output_contribution( + plan, + store, + &stage_value_evals, + &gamma_powers, + entry_bytecode_index, + r_address_prime, + r_cycle_prime, + log_k, + )?; + let bytecode_ra = eval_family_values(evals, plan.bytecode_ra_evals)? + .into_iter() + .product::(); + Ok(output_contrib * bytecode_ra) +} - let mut val = Fr::from_u64(0); - for (index, stage) in plan.stages.iter().enumerate() { - let cycle_point = stage67_bytecode_stage_cycle_point(store, stage, r_cycle_prime.len())?; - let int_contrib = stage - .identity_gamma_power - .map_or(Fr::from_u64(0), |power| gamma_powers[power] * int_eval); - val += (stage_value_evals[index] + int_contrib) - * EqPolynomial::::mle(&cycle_point, r_cycle_prime) - * gamma_powers[stage.output_gamma_power]; - } - +fn stage67_bytecode_output_contribution( + plan: &Stage67BytecodeReadRafPlan, + store: &ValueStore, + stage_value_evals: &[Fr], + gamma_powers: &[Fr], + entry_bytecode_index: usize, + r_address_prime: &[Fr], + r_cycle_prime: &[Fr], + log_k: usize, +) -> Result { + let int_eval = identity_polynomial_eval(r_address_prime); + let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; let entry_address_eq = EqPolynomial::::try_mle_at_boolean_index(entry_bytecode_index, r_address_prime).ok_or( RuntimePlanError::InvalidInputLength { @@ -303,14 +323,46 @@ pub fn evaluate_stage67_bytecode_read_raf( actual: entry_bytecode_index.saturating_add(1), }, )?; - let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; - let entry_contrib = gamma_powers[plan.entry_contribution.gamma_power] - * entry_address_eq - * EqPolynomial::::mle(&zero_cycle, r_cycle_prime); - let bytecode_ra = eval_family_values(evals, plan.bytecode_ra_evals)? - .into_iter() - .product::(); - Ok((val + entry_contrib) * bytecode_ra) + + let mut output = Fr::from_u64(0); + for term in plan.output_terms { + output += match *term { + Stage67BytecodeOutputTermPlan::StageValue { + stage_index, + gamma_power, + identity_gamma_power, + } => { + let stage = + plan.stages + .get(stage_index) + .ok_or(RuntimePlanError::InvalidInputLength { + input: plan.entries, + expected: stage_index + 1, + actual: plan.stages.len(), + })?; + let value = stage_value_evals.get(stage_index).copied().ok_or( + RuntimePlanError::InvalidInputLength { + input: plan.entries, + expected: stage_index + 1, + actual: stage_value_evals.len(), + }, + )?; + let cycle_point = + stage67_bytecode_stage_cycle_point(store, stage, r_cycle_prime.len())?; + let identity_contrib = identity_gamma_power + .map_or(Fr::from_u64(0), |power| gamma_powers[power] * int_eval); + (value + identity_contrib) + * EqPolynomial::::mle(&cycle_point, r_cycle_prime) + * gamma_powers[gamma_power] + } + Stage67BytecodeOutputTermPlan::Entry { gamma_power } => { + gamma_powers[gamma_power] + * entry_address_eq + * EqPolynomial::::mle(&zero_cycle, r_cycle_prime) + } + }; + } + Ok(output) } fn stage67_bytecode_stage_cycle_point( diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index d2a967827a..3193642c6f 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; -use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeEntryContributionPlan, Stage67BytecodeFlag, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols}; +use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -149,11 +149,20 @@ const STAGE6_BYTECODE_STAGE5_TERMS: &[Stage67BytecodeTermPlan] = &[ Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }, ]; const STAGE6_BYTECODE_STAGES: &[Stage67BytecodeStagePlan] = &[ - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage1_gamma", cycle_point: "stage6.input.stage1.Imm", register_point: None, output_gamma_power: 0, identity_gamma_power: Some(5), terms: STAGE6_BYTECODE_STAGE1_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage2_gamma", cycle_point: "stage6.input.stage2.OpFlagJump", register_point: None, output_gamma_power: 1, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE2_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage3_gamma", cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC", register_point: None, output_gamma_power: 2, identity_gamma_power: Some(4), terms: STAGE6_BYTECODE_STAGE3_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage4_gamma", cycle_point: "stage6.input.stage4.Rs1Ra", register_point: Some("stage6.input.stage4.Rs1Ra"), output_gamma_power: 3, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE4_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage5_gamma", cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa", register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"), output_gamma_power: 4, identity_gamma_power: None, terms: STAGE6_BYTECODE_STAGE5_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage1_gamma", cycle_point: "stage6.input.stage1.Imm", register_point: None, terms: STAGE6_BYTECODE_STAGE1_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage2_gamma", cycle_point: "stage6.input.stage2.OpFlagJump", register_point: None, terms: STAGE6_BYTECODE_STAGE2_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage3_gamma", cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC", register_point: None, terms: STAGE6_BYTECODE_STAGE3_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage4_gamma", cycle_point: "stage6.input.stage4.Rs1Ra", register_point: Some("stage6.input.stage4.Rs1Ra"), terms: STAGE6_BYTECODE_STAGE4_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage5_gamma", cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa", register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"), terms: STAGE6_BYTECODE_STAGE5_TERMS }, +]; + +const STAGE6_BYTECODE_OUTPUT_TERMS: &[Stage67BytecodeOutputTermPlan] = &[ + Stage67BytecodeOutputTermPlan::StageValue { stage_index: 0, gamma_power: 0, identity_gamma_power: Some(5) }, + Stage67BytecodeOutputTermPlan::StageValue { stage_index: 1, gamma_power: 1, identity_gamma_power: None }, + Stage67BytecodeOutputTermPlan::StageValue { stage_index: 2, gamma_power: 2, identity_gamma_power: Some(4) }, + Stage67BytecodeOutputTermPlan::StageValue { stage_index: 3, gamma_power: 3, identity_gamma_power: None }, + Stage67BytecodeOutputTermPlan::StageValue { stage_index: 4, gamma_power: 4, identity_gamma_power: None }, + Stage67BytecodeOutputTermPlan::Entry { gamma_power: 7 }, ]; const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { @@ -163,7 +172,7 @@ const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafP entries: "stage6.bytecode_read_raf.entries", entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", stages: STAGE6_BYTECODE_STAGES, - entry_contribution: Stage67BytecodeEntryContributionPlan { gamma_power: 7 }, + output_terms: STAGE6_BYTECODE_OUTPUT_TERMS, registers: Stage67BytecodeRegisterSymbols { rd: "stage6.bytecode.entry.rd", rs1: "stage6.bytecode.entry.rs1", From 8f43febec47c31190644e8600c3a6055a451b1c7 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 00:16:04 -0600 Subject: [PATCH 055/171] refactor(bolt): plan stage2 ram read-write output --- .../src/protocols/jolt/emit/rust/stage2.rs | 38 ++++++++++++++++--- crates/jolt-verifier/src/stages/stage2.rs | 35 ++++++++++++++--- 2 files changed, 61 insertions(+), 12 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 9939fd0b8f..5465249580 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -1033,6 +1033,15 @@ pub struct Stage2RamData<'a> { pub output_layout: Option, } +#[derive(Clone, Copy, Debug)] +pub struct Stage2RamReadWriteOutputPlan { + pub cycle_point: &'static str, + pub gamma: &'static str, + pub val_eval: &'static str, + pub ra_eval: &'static str, + pub inc_eval: &'static str, +} + #[derive(Clone, Debug, Default)] struct Stage2ValueStore(bolt_verifier_runtime::ValueStore); @@ -1090,6 +1099,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_verifier_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); + source.push_str(Self::emit_verifier_relation_output_constants()); source.push_str( "pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan {\n\ \x20 params: STAGE2_PARAMS,\n\ @@ -1112,6 +1122,16 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); Ok(source) } + fn emit_verifier_relation_output_constants() -> &'static str { + "pub const STAGE2_RAM_READ_WRITE_OUTPUT: Stage2RamReadWriteOutputPlan = Stage2RamReadWriteOutputPlan {\n\ + \x20 cycle_point: \"stage2.input.stage1.RamReadValue\",\n\ + \x20 gamma: \"stage2.ram_read_write.gamma\",\n\ + \x20 val_eval: \"stage2.ram_read_write.eval.RamVal\",\n\ + \x20 ra_eval: \"stage2.ram_read_write.eval.RamRa\",\n\ + \x20 inc_eval: \"stage2.ram_read_write.eval.RamInc\",\n\ + };\n\n" + } + fn emit_shared_constants(&self) -> Result { let mut source = String::new(); push_format( @@ -2186,7 +2206,12 @@ fn expected_batched_output_claim( })?; let value = match instance.relation { Stage2RelationKind::Stage2RamReadWrite => { - expected_ram_read_write(store, evals, local_point)? + expected_ram_read_write( + &STAGE2_RAM_READ_WRITE_OUTPUT, + store, + evals, + local_point, + )? } Stage2RelationKind::Stage2ProductVirtualRemainder => { expected_product_remainder(store, evals, local_point)? @@ -2206,18 +2231,19 @@ fn expected_batched_output_claim( } fn expected_ram_read_write( + plan: &'static Stage2RamReadWriteOutputPlan, store: &Stage2ValueStore, evals: &[Stage2NamedEval], local_point: &[Fr], ) -> Result { - let r_cycle_stage1 = store.point("stage2.input.stage1.RamReadValue")?; + let r_cycle_stage1 = store.point(plan.cycle_point)?; let log_t = r_cycle_stage1.len(); let r_cycle = reverse_slice(&local_point[..log_t]); let eq_eval = EqPolynomial::::mle(r_cycle_stage1, &r_cycle); - let gamma = store.scalar("stage2.ram_read_write.gamma")?; - let val = eval_by_name(evals, "stage2.ram_read_write.eval.RamVal")?; - let ra = eval_by_name(evals, "stage2.ram_read_write.eval.RamRa")?; - let inc = eval_by_name(evals, "stage2.ram_read_write.eval.RamInc")?; + let gamma = store.scalar(plan.gamma)?; + let val = eval_by_name(evals, plan.val_eval)?; + let ra = eval_by_name(evals, plan.ra_eval)?; + let inc = eval_by_name(evals, plan.inc_eval)?; Ok(eq_eval * ra * (val + gamma * (val + inc))) } diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index 4bbfd8221f..e45ed824e2 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -58,6 +58,15 @@ pub struct Stage2RamData<'a> { pub output_layout: Option, } +#[derive(Clone, Copy, Debug)] +pub struct Stage2RamReadWriteOutputPlan { + pub cycle_point: &'static str, + pub gamma: &'static str, + pub val_eval: &'static str, + pub ra_eval: &'static str, + pub inc_eval: &'static str, +} + #[derive(Clone, Debug, Default)] struct Stage2ValueStore(bolt_verifier_runtime::ValueStore); @@ -222,6 +231,14 @@ pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[ pub const STAGE2_OPENING_BATCHES: &[Stage2OpeningBatchPlan] = &[ Stage2OpeningBatchPlan { symbol: "stage2.openings", stage: "stage2", proof_slot: "stage2.openings", policy: "jolt_stage2_output_order", count: 18, ordered_claims: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"], claim_operands: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"] }, ]; +pub const STAGE2_RAM_READ_WRITE_OUTPUT: Stage2RamReadWriteOutputPlan = Stage2RamReadWriteOutputPlan { + cycle_point: "stage2.input.stage1.RamReadValue", + gamma: "stage2.ram_read_write.gamma", + val_eval: "stage2.ram_read_write.eval.RamVal", + ra_eval: "stage2.ram_read_write.eval.RamRa", + inc_eval: "stage2.ram_read_write.eval.RamInc", +}; + pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan { params: STAGE2_PARAMS, steps: STAGE2_PROGRAM_STEPS, @@ -670,7 +687,12 @@ fn expected_batched_output_claim( })?; let value = match instance.relation { Stage2RelationKind::Stage2RamReadWrite => { - expected_ram_read_write(store, evals, local_point)? + expected_ram_read_write( + &STAGE2_RAM_READ_WRITE_OUTPUT, + store, + evals, + local_point, + )? } Stage2RelationKind::Stage2ProductVirtualRemainder => { expected_product_remainder(store, evals, local_point)? @@ -690,18 +712,19 @@ fn expected_batched_output_claim( } fn expected_ram_read_write( + plan: &'static Stage2RamReadWriteOutputPlan, store: &Stage2ValueStore, evals: &[Stage2NamedEval], local_point: &[Fr], ) -> Result { - let r_cycle_stage1 = store.point("stage2.input.stage1.RamReadValue")?; + let r_cycle_stage1 = store.point(plan.cycle_point)?; let log_t = r_cycle_stage1.len(); let r_cycle = reverse_slice(&local_point[..log_t]); let eq_eval = EqPolynomial::::mle(r_cycle_stage1, &r_cycle); - let gamma = store.scalar("stage2.ram_read_write.gamma")?; - let val = eval_by_name(evals, "stage2.ram_read_write.eval.RamVal")?; - let ra = eval_by_name(evals, "stage2.ram_read_write.eval.RamRa")?; - let inc = eval_by_name(evals, "stage2.ram_read_write.eval.RamInc")?; + let gamma = store.scalar(plan.gamma)?; + let val = eval_by_name(evals, plan.val_eval)?; + let ra = eval_by_name(evals, plan.ra_eval)?; + let inc = eval_by_name(evals, plan.inc_eval)?; Ok(eq_eval * ra * (val + gamma * (val + inc))) } From 42e7825af9c8ffd16e579243518c7d4683e773f3 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 00:20:33 -0600 Subject: [PATCH 056/171] refactor(bolt): prune stale verifier point paths --- crates/bolt/src/protocols/jolt/emit/rust/stage6.rs | 3 +-- crates/bolt/src/protocols/jolt/emit/rust/stage7.rs | 1 - .../jolt/verifier_jolt_relations.rs.template | 13 +------------ crates/jolt-verifier/src/stages/jolt_relations.rs | 13 +------------ crates/jolt-verifier/src/stages/stage6.rs | 3 +-- crates/jolt-verifier/src/stages/stage7.rs | 1 - 6 files changed, 4 insertions(+), 30 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 4b62f540ab..741be0ec8a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1161,7 +1161,7 @@ impl Stage6CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ - use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\ + use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -2471,7 +2471,6 @@ fn observe_stage6_sumcheck_output( "reverse" => point.reverse(), "bytecode_read_raf" => point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?, "stage6_booleanity" => {} - "instruction_read_raf" => point = normalize_instruction_read_raf_point(&point, "stage6.instruction_read_raf.point")?, _ => { return Err(VerifyStage6Error::InvalidProof { driver: output.driver, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 005354af59..bcc8ca4764 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -2380,7 +2380,6 @@ fn observe_stage7_sumcheck_output( match instance.point_order { "as_is" => {} "reverse" => point.reverse(), - "stage7_booleanity" => {} _ => { return Err(VerifyStage7Error::InvalidProof { driver: output.driver, diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 07d01a524e..9836cc4eaa 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -15,8 +15,7 @@ //! - typed bytecode read-RAF plan data and its small Jolt-specific evaluator //! - the small Jolt-specific field-math helpers //! (`operand_polynomial_eval`, `identity_polynomial_eval`, -//! `lt_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt -//! verification +//! `bytecode_gamma_powers`) used only by Jolt verification //! //! Treat changes here as Jolt protocol changes, not as compiler-output //! cleanups. Generic Bolt verifier scaffolding (typed plan structs, @@ -653,13 +652,3 @@ pub fn identity_polynomial_eval(point: &[Fr]) -> Fr { .map(|(index, value)| value.mul_pow_2(point.len() - 1 - index)) .sum() } - -pub fn lt_polynomial_eval(x: &[Fr], y: &[Fr]) -> Fr { - let mut lt_eval = Fr::from_u64(0); - let mut eq_term = Fr::from_u64(1); - for (x_i, y_i) in x.iter().zip(y.iter()) { - lt_eval += (Fr::from_u64(1) - *x_i) * *y_i * eq_term; - eq_term *= Fr::from_u64(1) - *x_i - *y_i + *x_i * *y_i + *x_i * *y_i; - } - lt_eval -} diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 07d01a524e..9836cc4eaa 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -15,8 +15,7 @@ //! - typed bytecode read-RAF plan data and its small Jolt-specific evaluator //! - the small Jolt-specific field-math helpers //! (`operand_polynomial_eval`, `identity_polynomial_eval`, -//! `lt_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt -//! verification +//! `bytecode_gamma_powers`) used only by Jolt verification //! //! Treat changes here as Jolt protocol changes, not as compiler-output //! cleanups. Generic Bolt verifier scaffolding (typed plan structs, @@ -653,13 +652,3 @@ pub fn identity_polynomial_eval(point: &[Fr]) -> Fr { .map(|(index, value)| value.mul_pow_2(point.len() - 1 - index)) .sum() } - -pub fn lt_polynomial_eval(x: &[Fr], y: &[Fr]) -> Fr { - let mut lt_eval = Fr::from_u64(0); - let mut eq_term = Fr::from_u64(1); - for (x_i, y_i) in x.iter().zip(y.iter()) { - lt_eval += (Fr::from_u64(1) - *x_i) * *y_i * eq_term; - eq_term *= Fr::from_u64(1) - *x_i - *y_i + *x_i * *y_i + *x_i * *y_i; - } - lt_eval -} diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 3193642c6f..a5d744f59b 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; -use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, normalize_instruction_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols}; +use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -1047,7 +1047,6 @@ fn observe_stage6_sumcheck_output( "reverse" => point.reverse(), "bytecode_read_raf" => point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?, "stage6_booleanity" => {} - "instruction_read_raf" => point = normalize_instruction_read_raf_point(&point, "stage6.instruction_read_raf.point")?, _ => { return Err(VerifyStage6Error::InvalidProof { driver: output.driver, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index dbd1d870eb..d5e9cbda72 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -594,7 +594,6 @@ fn observe_stage7_sumcheck_output( match instance.point_order { "as_is" => {} "reverse" => point.reverse(), - "stage7_booleanity" => {} _ => { return Err(VerifyStage7Error::InvalidProof { driver: output.driver, From a65bb05e4150f751d054468a5e083d87276f04d8 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 00:29:08 -0600 Subject: [PATCH 057/171] refactor(bolt): type sumcheck point orders --- crates/bolt-verifier-runtime/src/lib.rs | 25 +++++++++++- .../protocols/jolt/emit/rust/plan_tokens.rs | 21 +++++++++- .../src/protocols/jolt/emit/rust/stage1.rs | 5 ++- .../src/protocols/jolt/emit/rust/stage2.rs | 9 +++-- .../src/protocols/jolt/emit/rust/stage3.rs | 9 +++-- .../src/protocols/jolt/emit/rust/stage4.rs | 11 ++++-- .../src/protocols/jolt/emit/rust/stage5.rs | 11 ++++-- .../src/protocols/jolt/emit/rust/stage6.rs | 13 ++++--- .../src/protocols/jolt/emit/rust/stage7.rs | 9 +++-- .../src/protocols/jolt/rust_target_plan.rs | 38 +++++++++++++++++++ crates/bolt/tests/verifier_cleanup.rs | 22 ++++++++++- crates/jolt-equivalence/src/plan_adapters.rs | 31 ++++++++++++++- .../jolt-verifier/src/stages/stage1_outer.rs | 4 +- crates/jolt-verifier/src/stages/stage2.rs | 16 ++++---- crates/jolt-verifier/src/stages/stage3.rs | 10 ++--- crates/jolt-verifier/src/stages/stage4.rs | 10 ++--- crates/jolt-verifier/src/stages/stage5.rs | 12 +++--- crates/jolt-verifier/src/stages/stage6.rs | 20 +++++----- crates/jolt-verifier/src/stages/stage7.rs | 6 +-- 19 files changed, 215 insertions(+), 67 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 98bf2d6ad1..01e2281c66 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -308,10 +308,33 @@ pub struct SumcheckInstanceResultPlan { pub point_arity: usize, pub num_rounds: usize, pub round_offset: usize, - pub point_order: &'static str, + pub point_order: SumcheckPointOrder, pub degree: usize, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SumcheckPointOrder { + AsIs, + Reverse, + Stage4RegistersReadWrite, + InstructionReadRaf, + BytecodeReadRaf, + Stage6Booleanity, +} + +impl SumcheckPointOrder { + pub fn as_str(self) -> &'static str { + match self { + Self::AsIs => "as_is", + Self::Reverse => "reverse", + Self::Stage4RegistersReadWrite => "stage4_registers_rw", + Self::InstructionReadRaf => "instruction_read_raf", + Self::BytecodeReadRaf => "bytecode_read_raf", + Self::Stage6Booleanity => "stage6_booleanity", + } + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum StructuredPolynomialPointOrder { AsIs, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index c64ee1f715..556749b2f5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -4,7 +4,7 @@ use crate::emit::rust::EmitError; use crate::ir::Role; use crate::protocols::jolt::rust_target_plan::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode, - ProgramStepKind, RustTargetPlanError, TranscriptSqueezeKind, + ProgramStepKind, RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, }; pub(super) fn role_program_step_kind_expr( @@ -160,6 +160,16 @@ pub(super) fn role_relation_kind_expr( relation_kind_expr(stage_type_prefix, relation) } +pub(super) fn role_sumcheck_point_order_expr( + role: &Role, + point_order: &str, +) -> Result { + if role == &Role::Prover { + return Ok(format!("{point_order:?}")); + } + sumcheck_point_order_expr(point_order) +} + pub(super) fn role_optional_relation_kind_expr( stage_type_prefix: &str, role: &Role, @@ -221,6 +231,15 @@ fn field_expr_kind_expr(stage_type_prefix: &str, formula: &str) -> Result Result { + let variant = SumcheckPointOrder::from_cpu_attr(point_order) + .map_err(plan_error)? + .rust_variant(); + Ok(format!( + "bolt_verifier_runtime::SumcheckPointOrder::{variant}" + )) +} + pub(super) fn pcs_proof_mode_expr( stage_type_prefix: &str, mode: &str, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs index 17a21441d7..c23c0ca74e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage1.rs @@ -761,7 +761,10 @@ impl Stage1CpuProgram { instance.point_arity, instance.num_rounds, instance.round_offset, - rust_str(&instance.point_order), + super::plan_tokens::role_sumcheck_point_order_expr( + &self.role, + &instance.point_order + )?, instance.degree )) }) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 5465249580..2d74aae65a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -1567,7 +1567,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); instance.point_arity, instance.num_rounds, instance.round_offset, - rust_str(&instance.point_order), + super::plan_tokens::role_sumcheck_point_order_expr( + &self.role, + &instance.point_order + )?, instance.degree )) }) @@ -2086,8 +2089,8 @@ impl Stage2ValueStore { output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), _ => { return Err(VerifyStage2Error::InvalidProof { driver: output.driver, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index ed35c95072..4db9fefb30 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1628,7 +1628,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); instance.point_arity, instance.num_rounds, instance.round_offset, - rust_str(&instance.point_order), + super::plan_tokens::role_sumcheck_point_order_expr( + &self.role, + &instance.point_order + )?, instance.degree )) }) @@ -2043,8 +2046,8 @@ fn observe_stage3_sumcheck_output( output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), _ => { return Err(VerifyStage3Error::InvalidProof { driver: output.driver, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 370166e540..6c9fbfa297 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -1832,7 +1832,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); instance.point_arity, instance.num_rounds, instance.round_offset, - rust_str(&instance.point_order), + super::plan_tokens::role_sumcheck_point_order_expr( + &self.role, + &instance.point_order + )?, instance.degree )) }) @@ -2257,9 +2260,9 @@ fn observe_stage4_sumcheck_output( output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), - "stage4_registers_rw" => { + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::Stage4RegistersReadWrite => { point = normalize_stage4_registers_rw_point(program, output.driver, &point)?; } _ => { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 08d2881f36..7bfd4c900a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1837,7 +1837,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); instance.point_arity, instance.num_rounds, instance.round_offset, - rust_str(&instance.point_order), + super::plan_tokens::role_sumcheck_point_order_expr( + &self.role, + &instance.point_order + )?, instance.degree )) }) @@ -2351,9 +2354,9 @@ fn observe_stage5_sumcheck_output( output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), - "instruction_read_raf" => { + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::InstructionReadRaf => { point = normalize_instruction_read_raf_point(&point, "stage5.instruction_read_raf.point")?; } _ => { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 741be0ec8a..4ffa61bb62 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1991,7 +1991,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); instance.point_arity, instance.num_rounds, instance.round_offset, - rust_str(&instance.point_order), + super::plan_tokens::role_sumcheck_point_order_expr( + &self.role, + &instance.point_order + )?, instance.degree )) }) @@ -2467,10 +2470,10 @@ fn observe_stage6_sumcheck_output( output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), - "bytecode_read_raf" => point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?, - "stage6_booleanity" => {} + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::BytecodeReadRaf => point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?, + bolt_verifier_runtime::SumcheckPointOrder::Stage6Booleanity => {} _ => { return Err(VerifyStage6Error::InvalidProof { driver: output.driver, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index bcc8ca4764..51b68b3a6d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1919,7 +1919,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); instance.point_arity, instance.num_rounds, instance.round_offset, - rust_str(&instance.point_order), + super::plan_tokens::role_sumcheck_point_order_expr( + &self.role, + &instance.point_order + )?, instance.degree )) }) @@ -2378,8 +2381,8 @@ fn observe_stage7_sumcheck_output( output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), _ => { return Err(VerifyStage7Error::InvalidProof { driver: output.driver, diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index 81ea211016..8d244864ff 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -102,6 +102,44 @@ impl ClaimKind { } } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum SumcheckPointOrder { + AsIs, + Reverse, + Stage4RegistersReadWrite, + InstructionReadRaf, + BytecodeReadRaf, + Stage6Booleanity, +} + +impl SumcheckPointOrder { + pub(crate) fn from_cpu_attr(value: &str) -> Result { + match value { + "as_is" => Ok(Self::AsIs), + "reverse" => Ok(Self::Reverse), + "stage4_registers_rw" => Ok(Self::Stage4RegistersReadWrite), + "instruction_read_raf" => Ok(Self::InstructionReadRaf), + "bytecode_read_raf" => Ok(Self::BytecodeReadRaf), + "stage6_booleanity" => Ok(Self::Stage6Booleanity), + _ => Err(RustTargetPlanError::unsupported( + "sumcheck point order", + value, + )), + } + } + + pub(crate) fn rust_variant(self) -> &'static str { + match self { + Self::AsIs => "AsIs", + Self::Reverse => "Reverse", + Self::Stage4RegistersReadWrite => "Stage4RegistersReadWrite", + Self::InstructionReadRaf => "InstructionReadRaf", + Self::BytecodeReadRaf => "BytecodeReadRaf", + Self::Stage6Booleanity => "Stage6Booleanity", + } + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum JoltVerifierRelationKind { Stage1OuterUniskip, diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 19c17e8615..3d4617f0de 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -36,6 +36,7 @@ const POINT_CONCAT_INPUT_STRING_SITE_BASELINE_CEILING: usize = 0; const STAGE_LOCAL_MACRO_RULES_BASELINE_CEILING: usize = 0; const STAGE_HELPER_FUNCTION_BASELINE_CEILING: usize = 38; const RELATION_STRING_SITE_BASELINE_CEILING: usize = 0; +const SUMCHECK_POINT_ORDER_STRING_SITE_BASELINE_CEILING: usize = 0; const ALLOWED_JOLT_PROTOCOL_SYMBOLS: &[&str] = &[ "jolt.commitment_phase", @@ -141,6 +142,7 @@ struct VerifierCleanupMetrics { stage_local_macro_rules: usize, stage_local_helper_functions: usize, relation_string_sites: usize, + sumcheck_point_order_string_sites: usize, } #[test] @@ -166,7 +168,8 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { point_concat_input_string_sites: {point_concat_input_string_sites} (baseline ceiling <= {point_concat_input_baseline})\n\ stage_local_macro_rules: {stage_local_macro_rules} (baseline ceiling <= {macro_rules_baseline})\n\ stage_local_helper_functions: {helper_functions} (baseline ceiling <= {helper_baseline})\n\ - relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})", + relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})\n\ + sumcheck_point_order_string_sites: {point_order_sites} (baseline ceiling <= {point_order_baseline})", generated_surface_loc = metrics.generated_surface_loc, bolt_runtime_loc = metrics.bolt_runtime_loc, bolt_runtime_baseline = BOLT_RUNTIME_BASELINE_LOC_CEILING, @@ -199,6 +202,8 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { helper_baseline = STAGE_HELPER_FUNCTION_BASELINE_CEILING, relation_sites = metrics.relation_string_sites, relation_baseline = RELATION_STRING_SITE_BASELINE_CEILING, + point_order_sites = metrics.sumcheck_point_order_string_sites, + point_order_baseline = SUMCHECK_POINT_ORDER_STRING_SITE_BASELINE_CEILING, ); assert!( @@ -282,6 +287,12 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { "relation string sites grew to {}; prefer typed relation plan data or explicit allowlists", metrics.relation_string_sites ); + assert!( + metrics.sumcheck_point_order_string_sites + == SUMCHECK_POINT_ORDER_STRING_SITE_BASELINE_CEILING, + "sumcheck point-order string sites grew to {}; prefer typed point-order plan data", + metrics.sumcheck_point_order_string_sites + ); } #[test] @@ -619,6 +630,8 @@ fn verifier_cleanup_metrics(verifier_src: &Path) -> VerifierCleanupMetrics { count_point_concat_input_string_sites(&source); metrics.stage_local_helper_functions += count_stage_local_helper_functions(&source); metrics.relation_string_sites += count_relation_string_sites(&source); + metrics.sumcheck_point_order_string_sites += + count_sumcheck_point_order_string_sites(&source); } } metrics @@ -723,6 +736,13 @@ fn count_relation_string_sites(source: &str) -> usize { .count() } +fn count_sumcheck_point_order_string_sites(source: &str) -> usize { + source + .lines() + .filter(|line| line.contains("point_order: \"")) + .count() +} + fn assert_allowed_jolt_protocol_symbol(path: &Path, symbol: &str) { assert!( ALLOWED_JOLT_PROTOCOL_SYMBOLS.contains(&symbol), diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index babe2a00ae..8afe44d599 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -32,6 +32,15 @@ macro_rules! stage_optional_relation_kind { }; } +macro_rules! stage_sumcheck_point_order { + (kernel, $value:expr) => { + super::leak_str($value) + }; + (generated, $value:expr) => { + super::generated_sumcheck_point_order($value) + }; +} + macro_rules! stage_claim { (kernel, $module:ident, $claim:ident, $plan:ident) => { $module::$claim { @@ -358,6 +367,24 @@ fn generated_structured_polynomial_point_order( } } +#[expect( + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" +)] +fn generated_sumcheck_point_order(value: &str) -> bolt_verifier_runtime::SumcheckPointOrder { + match value { + "as_is" => bolt_verifier_runtime::SumcheckPointOrder::AsIs, + "reverse" => bolt_verifier_runtime::SumcheckPointOrder::Reverse, + "stage4_registers_rw" => { + bolt_verifier_runtime::SumcheckPointOrder::Stage4RegistersReadWrite + } + "instruction_read_raf" => bolt_verifier_runtime::SumcheckPointOrder::InstructionReadRaf, + "bytecode_read_raf" => bolt_verifier_runtime::SumcheckPointOrder::BytecodeReadRaf, + "stage6_booleanity" => bolt_verifier_runtime::SumcheckPointOrder::Stage6Booleanity, + value => panic!("unsupported generated sumcheck point order `{value}`"), + } +} + #[expect( clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" @@ -573,7 +600,7 @@ macro_rules! define_stage_adapter_impl { point_arity: plan.point_arity, num_rounds: plan.num_rounds, round_offset: plan.round_offset, - point_order: super::leak_str(&plan.point_order), + point_order: stage_sumcheck_point_order!($mode, &plan.point_order), degree: plan.degree, }) .collect(), @@ -1026,7 +1053,7 @@ macro_rules! define_stage1_adapter { point_arity: plan.point_arity, num_rounds: plan.num_rounds, round_offset: plan.round_offset, - point_order: super::leak_str(&plan.point_order), + point_order: stage_sumcheck_point_order!($mode, &plan.point_order), degree: plan.degree, }) .collect(), diff --git a/crates/jolt-verifier/src/stages/stage1_outer.rs b/crates/jolt-verifier/src/stages/stage1_outer.rs index a6b0786bf7..95e1f4dae2 100644 --- a/crates/jolt-verifier/src/stages/stage1_outer.rs +++ b/crates/jolt-verifier/src/stages/stage1_outer.rs @@ -65,8 +65,8 @@ pub const STAGE1_SUMCHECK_DRIVERS: &[Stage1SumcheckDriverPlan] = &[ Stage1SumcheckDriverPlan { symbol: "stage1.outer_remaining.sumcheck", stage: "stage1", proof_slot: "stage1.sumcheck", kernel: None, relation: Some(Stage1RelationKind::Stage1OuterRemaining), batch: "stage1.outer_remaining.batch", policy: "jolt_core_front_loaded", round_schedule: STAGE1_SUMCHECK_DRIVER_1_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 17, degree: 3 }, ]; pub const STAGE1_SUMCHECK_INSTANCE_RESULTS: &[Stage1SumcheckInstanceResultPlan] = &[ - Stage1SumcheckInstanceResultPlan { symbol: "stage1.uniskip.instance", source: "stage1.uniskip.sumcheck", claim: "stage1.uniskip.input", relation: Stage1RelationKind::Stage1OuterUniskip, index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: "as_is", degree: 27 }, - Stage1SumcheckInstanceResultPlan { symbol: "stage1.outer_remaining.instance", source: "stage1.outer_remaining.sumcheck", claim: "stage1.outer_remaining.input", relation: Stage1RelationKind::Stage1OuterRemaining, index: 0, point_arity: 16, num_rounds: 17, round_offset: 1, point_order: "reverse", degree: 3 }, + Stage1SumcheckInstanceResultPlan { symbol: "stage1.uniskip.instance", source: "stage1.uniskip.sumcheck", claim: "stage1.uniskip.input", relation: Stage1RelationKind::Stage1OuterUniskip, index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::AsIs, degree: 27 }, + Stage1SumcheckInstanceResultPlan { symbol: "stage1.outer_remaining.instance", source: "stage1.outer_remaining.sumcheck", claim: "stage1.outer_remaining.input", relation: Stage1RelationKind::Stage1OuterRemaining, index: 0, point_arity: 16, num_rounds: 17, round_offset: 1, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, ]; pub const STAGE1_SUMCHECK_EVALS: &[Stage1SumcheckEvalPlan] = &[ diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index e45ed824e2..b946c9041a 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -169,12 +169,12 @@ pub const STAGE2_SUMCHECK_DRIVERS: &[Stage2SumcheckDriverPlan] = &[ Stage2SumcheckDriverPlan { symbol: "stage2.sumcheck", stage: "stage2", proof_slot: "stage2.sumcheck", kernel: None, relation: Some(Stage2RelationKind::Stage2Batched), batch: "stage2.batch", policy: "jolt_core_stage2_aligned", round_schedule: STAGE2_SUMCHECK_DRIVER_1_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 32, degree: 3 }, ]; pub const STAGE2_SUMCHECK_INSTANCE_RESULTS: &[Stage2SumcheckInstanceResultPlan] = &[ - Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.uniskip.instance", source: "stage2.product_virtual.uniskip.sumcheck", claim: "stage2.product_virtual.uniskip.input", relation: Stage2RelationKind::Stage2ProductVirtualUniskip, index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: "as_is", degree: 6 }, - Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_read_write.instance", source: "stage2.sumcheck", claim: "stage2.ram_read_write.input", relation: Stage2RelationKind::Stage2RamReadWrite, index: 0, point_arity: 32, num_rounds: 32, round_offset: 0, point_order: "reverse", degree: 3 }, - Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.remainder.instance", source: "stage2.sumcheck", claim: "stage2.product_virtual.remainder.input", relation: Stage2RelationKind::Stage2ProductVirtualRemainder, index: 1, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 3 }, - Stage2SumcheckInstanceResultPlan { symbol: "stage2.instruction_lookup.claim_reduction.instance", source: "stage2.sumcheck", claim: "stage2.instruction_lookup.claim_reduction.input", relation: Stage2RelationKind::Stage2InstructionLookupClaimReduction, index: 2, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 2 }, - Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_raf.instance", source: "stage2.sumcheck", claim: "stage2.ram_raf.input", relation: Stage2RelationKind::Stage2RamRafEvaluation, index: 3, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 2 }, - Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_output.instance", source: "stage2.sumcheck", claim: "stage2.ram_output.input", relation: Stage2RelationKind::Stage2RamOutputCheck, index: 4, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: "reverse", degree: 3 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.uniskip.instance", source: "stage2.product_virtual.uniskip.sumcheck", claim: "stage2.product_virtual.uniskip.input", relation: Stage2RelationKind::Stage2ProductVirtualUniskip, index: 0, point_arity: 1, num_rounds: 1, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::AsIs, degree: 6 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_read_write.instance", source: "stage2.sumcheck", claim: "stage2.ram_read_write.input", relation: Stage2RelationKind::Stage2RamReadWrite, index: 0, point_arity: 32, num_rounds: 32, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.product_virtual.remainder.instance", source: "stage2.sumcheck", claim: "stage2.product_virtual.remainder.input", relation: Stage2RelationKind::Stage2ProductVirtualRemainder, index: 1, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.instruction_lookup.claim_reduction.instance", source: "stage2.sumcheck", claim: "stage2.instruction_lookup.claim_reduction.input", relation: Stage2RelationKind::Stage2InstructionLookupClaimReduction, index: 2, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_raf.instance", source: "stage2.sumcheck", claim: "stage2.ram_raf.input", relation: Stage2RelationKind::Stage2RamRafEvaluation, index: 3, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 }, + Stage2SumcheckInstanceResultPlan { symbol: "stage2.ram_output.instance", source: "stage2.sumcheck", claim: "stage2.ram_output.input", relation: Stage2RelationKind::Stage2RamOutputCheck, index: 4, point_arity: 16, num_rounds: 16, round_offset: 16, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, ]; pub const STAGE2_SUMCHECK_EVALS: &[Stage2SumcheckEvalPlan] = &[ @@ -567,8 +567,8 @@ impl Stage2ValueStore { output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), _ => { return Err(VerifyStage2Error::InvalidProof { driver: output.driver, diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index f7eacddb52..e5f7157e0e 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -152,9 +152,9 @@ pub const STAGE3_SUMCHECK_DRIVERS: &[Stage3SumcheckDriverPlan] = &[ Stage3SumcheckDriverPlan { symbol: "stage3.sumcheck", stage: "stage3", proof_slot: "stage3.sumcheck", kernel: None, relation: Some(Stage3RelationKind::Stage3Batched), batch: "stage3.batch", policy: "jolt_core_stage3_aligned", round_schedule: STAGE3_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 16, degree: 3 }, ]; pub const STAGE3_SUMCHECK_INSTANCE_RESULTS: &[Stage3SumcheckInstanceResultPlan] = &[ - Stage3SumcheckInstanceResultPlan { symbol: "stage3.spartan_shift.instance", source: "stage3.sumcheck", claim: "stage3.spartan_shift.input", relation: Stage3RelationKind::Stage3SpartanShift, index: 0, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 2 }, - Stage3SumcheckInstanceResultPlan { symbol: "stage3.instruction_input.instance", source: "stage3.sumcheck", claim: "stage3.instruction_input.input", relation: Stage3RelationKind::Stage3InstructionInput, index: 1, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 3 }, - Stage3SumcheckInstanceResultPlan { symbol: "stage3.registers_claim_reduction.instance", source: "stage3.sumcheck", claim: "stage3.registers_claim_reduction.input", relation: Stage3RelationKind::Stage3RegistersClaimReduction, index: 2, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: "reverse", degree: 2 }, + Stage3SumcheckInstanceResultPlan { symbol: "stage3.spartan_shift.instance", source: "stage3.sumcheck", claim: "stage3.spartan_shift.input", relation: Stage3RelationKind::Stage3SpartanShift, index: 0, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 }, + Stage3SumcheckInstanceResultPlan { symbol: "stage3.instruction_input.instance", source: "stage3.sumcheck", claim: "stage3.instruction_input.input", relation: Stage3RelationKind::Stage3InstructionInput, index: 1, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, + Stage3SumcheckInstanceResultPlan { symbol: "stage3.registers_claim_reduction.instance", source: "stage3.sumcheck", claim: "stage3.registers_claim_reduction.input", relation: Stage3RelationKind::Stage3RegistersClaimReduction, index: 2, point_arity: 16, num_rounds: 16, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 }, ]; pub const STAGE3_SUMCHECK_EVALS: &[Stage3SumcheckEvalPlan] = &[ @@ -423,8 +423,8 @@ fn observe_stage3_sumcheck_output( output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), _ => { return Err(VerifyStage3Error::InvalidProof { driver: output.driver, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 424213dfa1..aff57d8dee 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -134,8 +134,8 @@ pub const STAGE4_SUMCHECK_DRIVERS: &[Stage4SumcheckDriverPlan] = &[ Stage4SumcheckDriverPlan { symbol: "stage4.sumcheck", stage: "stage4", proof_slot: "stage4.sumcheck", kernel: None, relation: Some(Stage4RelationKind::Stage4Batched), batch: "stage4.batch", policy: "jolt_core_stage4_aligned", round_schedule: STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 23, degree: 3 }, ]; pub const STAGE4_SUMCHECK_INSTANCE_RESULTS: &[Stage4SumcheckInstanceResultPlan] = &[ - Stage4SumcheckInstanceResultPlan { symbol: "stage4.registers_read_write.instance", source: "stage4.sumcheck", claim: "stage4.registers_read_write.input", relation: Stage4RelationKind::Stage4RegistersReadWrite, index: 0, point_arity: 23, num_rounds: 23, round_offset: 0, point_order: "stage4_registers_rw", degree: 3 }, - Stage4SumcheckInstanceResultPlan { symbol: "stage4.ram_val_check.instance", source: "stage4.sumcheck", claim: "stage4.ram_val_check.input", relation: Stage4RelationKind::Stage4RamValCheck, index: 1, point_arity: 16, num_rounds: 16, round_offset: 7, point_order: "reverse", degree: 3 }, + Stage4SumcheckInstanceResultPlan { symbol: "stage4.registers_read_write.instance", source: "stage4.sumcheck", claim: "stage4.registers_read_write.input", relation: Stage4RelationKind::Stage4RegistersReadWrite, index: 0, point_arity: 23, num_rounds: 23, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Stage4RegistersReadWrite, degree: 3 }, + Stage4SumcheckInstanceResultPlan { symbol: "stage4.ram_val_check.instance", source: "stage4.sumcheck", claim: "stage4.ram_val_check.input", relation: Stage4RelationKind::Stage4RamValCheck, index: 1, point_arity: 16, num_rounds: 16, round_offset: 7, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, ]; pub const STAGE4_SUMCHECK_EVALS: &[Stage4SumcheckEvalPlan] = &[ @@ -397,9 +397,9 @@ fn observe_stage4_sumcheck_output( output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), - "stage4_registers_rw" => { + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::Stage4RegistersReadWrite => { point = normalize_stage4_registers_rw_point(program, output.driver, &point)?; } _ => { diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index e770635cea..69ad0fde44 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -131,9 +131,9 @@ pub const STAGE5_SUMCHECK_DRIVERS: &[Stage5SumcheckDriverPlan] = &[ Stage5SumcheckDriverPlan { symbol: "stage5.sumcheck", stage: "stage5", proof_slot: "stage5.sumcheck", kernel: None, relation: Some(Stage5RelationKind::Stage5Batched), batch: "stage5.batch", policy: "jolt_core_stage5_aligned", round_schedule: STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 144, degree: 10 }, ]; pub const STAGE5_SUMCHECK_INSTANCE_RESULTS: &[Stage5SumcheckInstanceResultPlan] = &[ - Stage5SumcheckInstanceResultPlan { symbol: "stage5.instruction_read_raf.instance", source: "stage5.sumcheck", claim: "stage5.instruction_read_raf.input", relation: Stage5RelationKind::Stage5InstructionReadRaf, index: 0, point_arity: 144, num_rounds: 144, round_offset: 0, point_order: "instruction_read_raf", degree: 10 }, - Stage5SumcheckInstanceResultPlan { symbol: "stage5.ram_ra_claim_reduction.instance", source: "stage5.sumcheck", claim: "stage5.ram_ra_claim_reduction.input", relation: Stage5RelationKind::Stage5RamRaClaimReduction, index: 1, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: "reverse", degree: 2 }, - Stage5SumcheckInstanceResultPlan { symbol: "stage5.registers_val_evaluation.instance", source: "stage5.sumcheck", claim: "stage5.registers_val_evaluation.input", relation: Stage5RelationKind::Stage5RegistersValEvaluation, index: 2, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: "reverse", degree: 3 }, + Stage5SumcheckInstanceResultPlan { symbol: "stage5.instruction_read_raf.instance", source: "stage5.sumcheck", claim: "stage5.instruction_read_raf.input", relation: Stage5RelationKind::Stage5InstructionReadRaf, index: 0, point_arity: 144, num_rounds: 144, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::InstructionReadRaf, degree: 10 }, + Stage5SumcheckInstanceResultPlan { symbol: "stage5.ram_ra_claim_reduction.instance", source: "stage5.sumcheck", claim: "stage5.ram_ra_claim_reduction.input", relation: Stage5RelationKind::Stage5RamRaClaimReduction, index: 1, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 }, + Stage5SumcheckInstanceResultPlan { symbol: "stage5.registers_val_evaluation.instance", source: "stage5.sumcheck", claim: "stage5.registers_val_evaluation.input", relation: Stage5RelationKind::Stage5RegistersValEvaluation, index: 2, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, ]; pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[ @@ -524,9 +524,9 @@ fn observe_stage5_sumcheck_output( output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), - "instruction_read_raf" => { + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::InstructionReadRaf => { point = normalize_instruction_read_raf_point(&point, "stage5.instruction_read_raf.point")?; } _ => { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index a5d744f59b..a375b33ecf 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -410,12 +410,12 @@ pub const STAGE6_SUMCHECK_DRIVERS: &[Stage6SumcheckDriverPlan] = &[ Stage6SumcheckDriverPlan { symbol: "stage6.sumcheck", stage: "stage6", proof_slot: "stage6.sumcheck", kernel: None, relation: Some(Stage6RelationKind::Stage6Batched), batch: "stage6.batch", policy: "jolt_core_stage6_aligned", round_schedule: STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 26, degree: 5 }, ]; pub const STAGE6_SUMCHECK_INSTANCE_RESULTS: &[Stage6SumcheckInstanceResultPlan] = &[ - Stage6SumcheckInstanceResultPlan { symbol: "stage6.bytecode_read_raf.instance", source: "stage6.sumcheck", claim: "stage6.bytecode_read_raf.input", relation: Stage6RelationKind::Stage6BytecodeReadRaf, index: 0, point_arity: 26, num_rounds: 26, round_offset: 0, point_order: "bytecode_read_raf", degree: 4 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.booleanity.instance", source: "stage6.sumcheck", claim: "stage6.booleanity.input", relation: Stage6RelationKind::Stage6Booleanity, index: 1, point_arity: 20, num_rounds: 20, round_offset: 6, point_order: "stage6_booleanity", degree: 3 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.hamming_booleanity.instance", source: "stage6.sumcheck", claim: "stage6.hamming_booleanity.input", relation: Stage6RelationKind::Stage6HammingBooleanity, index: 2, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 3 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.ram_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.ram_ra_virtual.input", relation: Stage6RelationKind::Stage6RamRaVirtual, index: 3, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 5 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.instruction_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.instruction_ra_virtual.input", relation: Stage6RelationKind::Stage6InstructionRaVirtual, index: 4, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 5 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.inc_claim_reduction.instance", source: "stage6.sumcheck", claim: "stage6.inc_claim_reduction.input", relation: Stage6RelationKind::Stage6IncClaimReduction, index: 5, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: "reverse", degree: 2 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.bytecode_read_raf.instance", source: "stage6.sumcheck", claim: "stage6.bytecode_read_raf.input", relation: Stage6RelationKind::Stage6BytecodeReadRaf, index: 0, point_arity: 26, num_rounds: 26, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::BytecodeReadRaf, degree: 4 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.booleanity.instance", source: "stage6.sumcheck", claim: "stage6.booleanity.input", relation: Stage6RelationKind::Stage6Booleanity, index: 1, point_arity: 20, num_rounds: 20, round_offset: 6, point_order: bolt_verifier_runtime::SumcheckPointOrder::Stage6Booleanity, degree: 3 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.hamming_booleanity.instance", source: "stage6.sumcheck", claim: "stage6.hamming_booleanity.input", relation: Stage6RelationKind::Stage6HammingBooleanity, index: 2, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.ram_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.ram_ra_virtual.input", relation: Stage6RelationKind::Stage6RamRaVirtual, index: 3, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 5 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.instruction_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.instruction_ra_virtual.input", relation: Stage6RelationKind::Stage6InstructionRaVirtual, index: 4, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 5 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.inc_claim_reduction.instance", source: "stage6.sumcheck", claim: "stage6.inc_claim_reduction.input", relation: Stage6RelationKind::Stage6IncClaimReduction, index: 5, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 }, ]; const fn stage6_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage6SumcheckEvalPlan { @@ -1043,10 +1043,10 @@ fn observe_stage6_sumcheck_output( output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), - "bytecode_read_raf" => point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?, - "stage6_booleanity" => {} + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::BytecodeReadRaf => point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?, + bolt_verifier_runtime::SumcheckPointOrder::Stage6Booleanity => {} _ => { return Err(VerifyStage6Error::InvalidProof { driver: output.driver, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index d5e9cbda72..d48f506615 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -292,7 +292,7 @@ pub const STAGE7_SUMCHECK_OUTPUT_CLAIMS: &[Stage7SumcheckOutputClaimPlan] = &[ ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ - Stage7SumcheckInstanceResultPlan { symbol: "stage7.hamming_weight_claim_reduction.instance", source: "stage7.sumcheck", claim: "stage7.hamming_weight_claim_reduction.input", relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, index: 0, point_arity: 4, num_rounds: 4, round_offset: 0, point_order: "reverse", degree: 2 }, + Stage7SumcheckInstanceResultPlan { symbol: "stage7.hamming_weight_claim_reduction.instance", source: "stage7.sumcheck", claim: "stage7.hamming_weight_claim_reduction.input", relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, index: 0, point_arity: 4, num_rounds: 4, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 }, ]; const fn stage7_sumcheck_eval(symbol: &'static str, source: &'static str, name: &'static str, index: usize, oracle: &'static str) -> Stage7SumcheckEvalPlan { @@ -592,8 +592,8 @@ fn observe_stage7_sumcheck_output( output, |instance, mut point| { match instance.point_order { - "as_is" => {} - "reverse" => point.reverse(), + bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} + bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), _ => { return Err(VerifyStage7Error::InvalidProof { driver: output.driver, From bacd63c001c1378ae27aa78aa668c48f33c2e9ec Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 00:47:47 -0600 Subject: [PATCH 058/171] refactor(bolt): introduce verifier plan pilot --- .../src/protocols/jolt/emit/rust/stage3.rs | 294 +++++++++++++++--- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../bolt/src/protocols/jolt/verifier_plan.rs | 269 ++++++++++++++++ 3 files changed, 520 insertions(+), 44 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_plan.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 4db9fefb30..83c5e56fac 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -12,11 +12,13 @@ use super::output_claims::{ }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage3CpuProgram { pub role: Role, + pub(crate) verifier_plan: Option, pub params: Stage3Params, pub steps: Vec, pub transcript_squeezes: Vec, @@ -545,6 +547,7 @@ impl Stage3CpuProgram { let role = module .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; + let is_verifier = role == Role::Verifier; if role == Role::Prover { super::output_claims::prune_output_only_field_exprs( &mut field_exprs, @@ -568,9 +571,10 @@ impl Stage3CpuProgram { Vec::new() }; - Ok(Self { + let mut program = Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, role, + verifier_plan: None, steps, transcript_squeezes, opening_inputs, @@ -589,9 +593,105 @@ impl Stage3CpuProgram { opening_claims, opening_equalities, opening_batches, + }; + if is_verifier { + program.verifier_plan = Some(program.plan_verifier()?); + } + Ok(program) + } + + fn plan_verifier(&self) -> Result { + Ok(VerifierStagePlan { + steps: self + .steps + .iter() + .map(|step| { + verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) + }) + .collect::, _>>()?, + transcript_squeezes: self + .transcript_squeezes + .iter() + .map(|squeeze| { + verifier_plan::VerifierTranscriptSqueezePlan::from_cpu( + &squeeze.symbol, + &squeeze.label, + &squeeze.kind, + squeeze.count, + ) + }) + .collect::, _>>()?, + opening_inputs: self + .opening_inputs + .iter() + .map(|input| { + verifier_plan::VerifierOpeningInputPlan::from_cpu( + &input.symbol, + &input.source_stage, + &input.source_claim, + &input.oracle, + &input.domain, + input.point_arity, + &input.claim_kind, + ) + }) + .collect::, _>>()?, + field_exprs: self + .field_exprs + .iter() + .map(|expr| { + verifier_plan::VerifierFieldExprPlan::from_cpu( + &expr.symbol, + &expr.formula, + &expr.operands, + ) + }) + .collect::, _>>()?, + claims: self + .claims + .iter() + .map(|claim| { + verifier_plan::VerifierSumcheckClaimPlan::from_cpu(claim.relation.as_deref()) + }) + .collect::, _>>()?, + drivers: self + .drivers + .iter() + .map(|driver| { + verifier_plan::VerifierSumcheckDriverPlan::from_cpu(driver.relation.as_deref()) + }) + .collect::, _>>()?, + instance_results: self + .instance_results + .iter() + .map(|instance| { + verifier_plan::VerifierSumcheckInstanceResultPlan::from_cpu( + &instance.relation, + &instance.point_order, + ) + }) + .collect::, _>>()?, + opening_claims: self + .opening_claims + .iter() + .map(|claim| verifier_plan::VerifierOpeningClaimPlan::from_cpu(&claim.claim_kind)) + .collect::, _>>()?, + opening_equalities: self + .opening_equalities + .iter() + .map(|equality| { + verifier_plan::VerifierOpeningClaimEqualityPlan::from_cpu(&equality.mode) + }) + .collect::, _>>()?, }) } + fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { + self.verifier_plan + .as_ref() + .ok_or_else(|| EmitError::new("missing stage3 verifier plan")) + } + fn verify_supported_target(&self) -> Result<(), EmitError> { require_supported_symbol("field", &self.params.field, "bn254_fr")?; require_supported_symbol("pcs", &self.params.pcs, "dory")?; @@ -1212,6 +1312,24 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_program_step_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + let steps = plan + .steps + .iter() + .map(|step| { + format!( + " Stage3ProgramStepPlan {{ kind: {}, symbol: {} }},", + verifier_plan::program_step_kind_expr("Stage3", step.kind), + rust_str(&step.symbol), + ) + }) + .collect::>() + .join("\n"); + return Ok(format!( + "pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[\n{steps}\n];\n\n" + )); + } let steps = self .steps .iter() @@ -1232,6 +1350,26 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_transcript_squeeze_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + let squeezes = plan + .transcript_squeezes + .iter() + .map(|squeeze| { + format!( + " Stage3TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},", + rust_str(&squeeze.symbol), + rust_str(&squeeze.label), + verifier_plan::transcript_squeeze_kind_expr("Stage3", squeeze.kind), + squeeze.count, + ) + }) + .collect::>() + .join("\n"); + return Ok(format!( + "pub const STAGE3_TRANSCRIPT_SQUEEZES: &[Stage3TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n" + )); + } let squeezes = self .transcript_squeezes .iter() @@ -1256,6 +1394,29 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_opening_input_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + let inputs = plan + .opening_inputs + .iter() + .map(|input| { + format!( + " Stage3OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},", + rust_str(&input.symbol), + rust_str(&input.source_stage), + rust_str(&input.source_claim), + rust_str(&input.oracle), + rust_str(&input.domain), + input.point_arity, + verifier_plan::claim_kind_expr("Stage3", input.claim_kind) + ) + }) + .collect::>() + .join("\n"); + return Ok(format!( + "pub const STAGE3_OPENING_INPUTS: &[Stage3OpeningInputPlan] = &[\n{inputs}\n];\n\n" + )); + } let inputs = self .opening_inputs .iter() @@ -1299,22 +1460,19 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { - let exprs = self + let plan = self.verifier_plan()?; + let exprs = plan .field_exprs .iter() .map(|expr| { - Ok(format!( + format!( " Stage3FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", rust_str(&expr.symbol), - super::plan_tokens::role_field_expr_kind_expr( - "Stage3", - &self.role, - &expr.formula - )?, + verifier_plan::field_expr_kind_expr("Stage3", expr.kind), super::plan_tokens::rust_str_slice_expr(&expr.operands) - )) + ) }) - .collect::, EmitError>>()? + .collect::>() .join("\n"); return Ok(format!( "pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[\n{exprs}\n];\n" @@ -1419,9 +1577,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); rust_str(&claim.claim_value) )); } else { - let relation = claim.relation.as_deref().ok_or_else(|| { - missing_role_binding("verifier claim relation", &claim.symbol) - })?; + let relation = self.verifier_plan()?.claim_relation(index)?; claims.push(format!( " Stage3SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {} }},", rust_str(&claim.symbol), @@ -1430,11 +1586,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); claim.num_rounds, claim.degree, rust_str(&claim.claim), - super::plan_tokens::role_relation_kind_expr( - "Stage3", - &self.role, - relation - )?, + verifier_plan::relation_kind_expr("Stage3", relation), rust_str(&claim.claim_value) )); } @@ -1565,19 +1717,13 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); driver.degree )); } else { - let relation = driver.relation.as_deref().ok_or_else(|| { - missing_role_binding("verifier driver relation", &driver.symbol) - })?; + let relation = self.verifier_plan()?.driver_relation(index)?; drivers.push(format!( " Stage3SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: None, relation: Some({}), batch: {}, policy: {}, round_schedule: STAGE3_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},", rust_str(&driver.symbol), rust_str(&driver.stage), rust_str(&driver.proof_slot), - super::plan_tokens::role_relation_kind_expr( - "Stage3", - &self.role, - relation - )?, + verifier_plan::relation_kind_expr("Stage3", relation), rust_str(&driver.batch), rust_str(&driver.policy), rust_str(&driver.claim_label), @@ -1610,28 +1756,54 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_sumcheck_instance_result_constants(&self) -> Result { + let verifier_plan = if self.role == Role::Verifier { + Some(self.verifier_plan()?) + } else { + None + }; let instances = self .instance_results .iter() - .map(|instance| { + .enumerate() + .map(|(index, instance)| { + let relation = verifier_plan + .and_then(|plan| plan.instance_results.get(index)) + .map_or_else( + || { + super::plan_tokens::role_relation_kind_expr( + "Stage3", + &self.role, + &instance.relation, + ) + }, + |planned| { + Ok(verifier_plan::relation_kind_expr("Stage3", planned.relation)) + }, + )?; + let point_order = verifier_plan + .and_then(|plan| plan.instance_results.get(index)) + .map_or_else( + || { + super::plan_tokens::role_sumcheck_point_order_expr( + &self.role, + &instance.point_order, + ) + }, + |planned| { + Ok(verifier_plan::sumcheck_point_order_expr(planned.point_order)) + }, + )?; Ok(format!( " Stage3SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},", rust_str(&instance.symbol), rust_str(&instance.source), rust_str(&instance.claim), - super::plan_tokens::role_relation_kind_expr( - "Stage3", - &self.role, - &instance.relation - )?, + relation, instance.index, instance.point_arity, instance.num_rounds, instance.round_offset, - super::plan_tokens::role_sumcheck_point_order_expr( - &self.role, - &instance.point_order - )?, + point_order, instance.degree )) }) @@ -1740,17 +1912,35 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_opening_claim_constants(&self) -> Result { + let verifier_plan = if self.role == Role::Verifier { + Some(self.verifier_plan()?) + } else { + None + }; let claims = self .opening_claims .iter() - .map(|claim| { + .enumerate() + .map(|(index, claim)| { + let claim_kind = verifier_plan + .and_then(|plan| plan.opening_claims.get(index)) + .map_or_else( + || { + super::plan_tokens::role_claim_kind_expr( + "Stage3", + &self.role, + &claim.claim_kind, + ) + }, + |planned| Ok(verifier_plan::claim_kind_expr("Stage3", planned.claim_kind)), + )?; Ok(format!( " Stage3OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},", rust_str(&claim.symbol), rust_str(&claim.oracle), rust_str(&claim.domain), claim.point_arity, - super::plan_tokens::role_claim_kind_expr("Stage3", &self.role, &claim.claim_kind)?, + claim_kind, rust_str(&claim.point_source), rust_str(&claim.eval_source) )) @@ -1763,18 +1953,34 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_opening_claim_equality_constants(&self) -> Result { + let verifier_plan = if self.role == Role::Verifier { + Some(self.verifier_plan()?) + } else { + None + }; let equalities = self .opening_equalities .iter() - .map(|equality| { + .enumerate() + .map(|(index, equality)| { + let mode = verifier_plan + .and_then(|plan| plan.opening_equalities.get(index)) + .map_or_else( + || { + super::plan_tokens::role_opening_equality_mode_expr( + "Stage3", + &self.role, + &equality.mode, + ) + }, + |planned| { + Ok(verifier_plan::opening_equality_mode_expr("Stage3", planned.mode)) + }, + )?; Ok(format!( " Stage3OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},", rust_str(&equality.symbol), - super::plan_tokens::role_opening_equality_mode_expr( - "Stage3", - &self.role, - &equality.mode - )?, + mode, rust_str(&equality.lhs), rust_str(&equality.rhs) )) diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index d4b352c418..497f167940 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -6,6 +6,7 @@ pub mod phases; pub(crate) mod rust_target_plan; pub(crate) mod stage6_bytecode_read_raf_plan; pub mod validate; +pub(crate) mod verifier_plan; pub use artifacts::{ assemble_jolt_generated_crates, assemble_jolt_workspace_generated_crates, jolt_artifact_config, diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs new file mode 100644 index 0000000000..2e340b87e7 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -0,0 +1,269 @@ +use crate::emit::rust::EmitError; +use crate::protocols::jolt::rust_target_plan::{ + ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, ProgramStepKind, + RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, +}; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierProgramStepPlan { + pub(crate) kind: ProgramStepKind, + pub(crate) symbol: String, +} + +impl VerifierProgramStepPlan { + pub(crate) fn from_cpu(kind: &str, symbol: &str) -> Result { + Ok(Self { + kind: ProgramStepKind::from_cpu_attr(kind).map_err(plan_error)?, + symbol: symbol.to_owned(), + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierTranscriptSqueezePlan { + pub(crate) symbol: String, + pub(crate) label: String, + pub(crate) kind: TranscriptSqueezeKind, + pub(crate) count: usize, +} + +impl VerifierTranscriptSqueezePlan { + pub(crate) fn from_cpu( + symbol: &str, + label: &str, + kind: &str, + count: usize, + ) -> Result { + Ok(Self { + symbol: symbol.to_owned(), + label: label.to_owned(), + kind: TranscriptSqueezeKind::from_cpu_attr(kind).map_err(plan_error)?, + count, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierOpeningInputPlan { + pub(crate) symbol: String, + pub(crate) source_stage: String, + pub(crate) source_claim: String, + pub(crate) oracle: String, + pub(crate) domain: String, + pub(crate) point_arity: usize, + pub(crate) claim_kind: ClaimKind, +} + +impl VerifierOpeningInputPlan { + pub(crate) fn from_cpu( + symbol: &str, + source_stage: &str, + source_claim: &str, + oracle: &str, + domain: &str, + point_arity: usize, + claim_kind: &str, + ) -> Result { + Ok(Self { + symbol: symbol.to_owned(), + source_stage: source_stage.to_owned(), + source_claim: source_claim.to_owned(), + oracle: oracle.to_owned(), + domain: domain.to_owned(), + point_arity, + claim_kind: ClaimKind::from_cpu_attr(claim_kind).map_err(plan_error)?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierFieldExprPlan { + pub(crate) symbol: String, + pub(crate) kind: FieldExprKind, + pub(crate) operands: Vec, +} + +impl VerifierFieldExprPlan { + pub(crate) fn from_cpu( + symbol: &str, + formula: &str, + operands: &[String], + ) -> Result { + Ok(Self { + symbol: symbol.to_owned(), + kind: FieldExprKind::from_cpu_attr(formula).map_err(plan_error)?, + operands: operands.to_vec(), + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierSumcheckClaimPlan { + pub(crate) relation: Option, +} + +impl VerifierSumcheckClaimPlan { + pub(crate) fn from_cpu(relation: Option<&str>) -> Result { + Ok(Self { + relation: relation + .map(JoltVerifierRelationKind::from_cpu_attr) + .transpose() + .map_err(plan_error)?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierSumcheckDriverPlan { + pub(crate) relation: Option, +} + +impl VerifierSumcheckDriverPlan { + pub(crate) fn from_cpu(relation: Option<&str>) -> Result { + Ok(Self { + relation: relation + .map(JoltVerifierRelationKind::from_cpu_attr) + .transpose() + .map_err(plan_error)?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierSumcheckInstanceResultPlan { + pub(crate) relation: JoltVerifierRelationKind, + pub(crate) point_order: SumcheckPointOrder, +} + +impl VerifierSumcheckInstanceResultPlan { + pub(crate) fn from_cpu(relation: &str, point_order: &str) -> Result { + Ok(Self { + relation: JoltVerifierRelationKind::from_cpu_attr(relation).map_err(plan_error)?, + point_order: SumcheckPointOrder::from_cpu_attr(point_order).map_err(plan_error)?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierOpeningClaimPlan { + pub(crate) claim_kind: ClaimKind, +} + +impl VerifierOpeningClaimPlan { + pub(crate) fn from_cpu(claim_kind: &str) -> Result { + Ok(Self { + claim_kind: ClaimKind::from_cpu_attr(claim_kind).map_err(plan_error)?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierOpeningClaimEqualityPlan { + pub(crate) mode: OpeningEqualityMode, +} + +impl VerifierOpeningClaimEqualityPlan { + pub(crate) fn from_cpu(mode: &str) -> Result { + Ok(Self { + mode: OpeningEqualityMode::from_cpu_attr(mode).map_err(plan_error)?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierStagePlan { + pub(crate) steps: Vec, + pub(crate) transcript_squeezes: Vec, + pub(crate) opening_inputs: Vec, + pub(crate) field_exprs: Vec, + pub(crate) claims: Vec, + pub(crate) drivers: Vec, + pub(crate) instance_results: Vec, + pub(crate) opening_claims: Vec, + pub(crate) opening_equalities: Vec, +} + +impl VerifierStagePlan { + pub(crate) fn claim_relation( + &self, + index: usize, + ) -> Result { + self.claims + .get(index) + .and_then(|claim| claim.relation) + .ok_or_else(|| missing_plan_row("claim relation", index)) + } + + pub(crate) fn driver_relation( + &self, + index: usize, + ) -> Result { + self.drivers + .get(index) + .and_then(|driver| driver.relation) + .ok_or_else(|| missing_plan_row("driver relation", index)) + } +} + +pub(crate) fn relation_kind_expr( + stage_type_prefix: &str, + relation: JoltVerifierRelationKind, +) -> String { + format!( + "{stage_type_prefix}RelationKind::{}", + relation.rust_variant() + ) +} + +pub(crate) fn program_step_kind_expr(stage_type_prefix: &str, kind: ProgramStepKind) -> String { + format!( + "{stage_type_prefix}ProgramStepKind::{}", + kind.rust_variant() + ) +} + +pub(crate) fn transcript_squeeze_kind_expr( + stage_type_prefix: &str, + kind: TranscriptSqueezeKind, +) -> String { + format!( + "{stage_type_prefix}TranscriptSqueezeKind::{}", + kind.rust_variant() + ) +} + +pub(crate) fn claim_kind_expr(stage_type_prefix: &str, kind: ClaimKind) -> String { + format!("{stage_type_prefix}ClaimKind::{}", kind.rust_variant()) +} + +pub(crate) fn field_expr_kind_expr(stage_type_prefix: &str, kind: FieldExprKind) -> String { + format!( + "{stage_type_prefix}FieldExprKind::{}", + kind.rust_variant_expr() + ) +} + +pub(crate) fn sumcheck_point_order_expr(point_order: SumcheckPointOrder) -> String { + format!( + "bolt_verifier_runtime::SumcheckPointOrder::{}", + point_order.rust_variant() + ) +} + +pub(crate) fn opening_equality_mode_expr( + stage_type_prefix: &str, + mode: OpeningEqualityMode, +) -> String { + format!( + "{stage_type_prefix}OpeningEqualityMode::{}", + mode.rust_variant() + ) +} + +fn missing_plan_row(kind: &'static str, index: usize) -> EmitError { + EmitError::new(format!("missing verifier-plan {kind} at index {index}")) +} + +fn plan_error(error: RustTargetPlanError) -> EmitError { + EmitError::new(error.to_string()) +} From 3defb4b43390731492e859029c4f774ae4fed388 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 00:50:45 -0600 Subject: [PATCH 059/171] refactor(bolt): share verifier plan projection --- .../src/protocols/jolt/emit/rust/stage3.rs | 80 +++---------- .../bolt/src/protocols/jolt/verifier_plan.rs | 108 ++++++++++++++++++ 2 files changed, 124 insertions(+), 64 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 83c5e56fac..a529fd56a8 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1314,20 +1314,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); fn emit_program_step_constants(&self) -> Result { if self.role == Role::Verifier { let plan = self.verifier_plan()?; - let steps = plan - .steps - .iter() - .map(|step| { - format!( - " Stage3ProgramStepPlan {{ kind: {}, symbol: {} }},", - verifier_plan::program_step_kind_expr("Stage3", step.kind), - rust_str(&step.symbol), - ) - }) - .collect::>() - .join("\n"); - return Ok(format!( - "pub const STAGE3_PROGRAM_STEPS: &[Stage3ProgramStepPlan] = &[\n{steps}\n];\n\n" + return Ok(verifier_plan::emit_program_step_constants( + "Stage3", + "STAGE3", + &plan.steps, )); } let steps = self @@ -1352,22 +1342,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); fn emit_transcript_squeeze_constants(&self) -> Result { if self.role == Role::Verifier { let plan = self.verifier_plan()?; - let squeezes = plan - .transcript_squeezes - .iter() - .map(|squeeze| { - format!( - " Stage3TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},", - rust_str(&squeeze.symbol), - rust_str(&squeeze.label), - verifier_plan::transcript_squeeze_kind_expr("Stage3", squeeze.kind), - squeeze.count, - ) - }) - .collect::>() - .join("\n"); - return Ok(format!( - "pub const STAGE3_TRANSCRIPT_SQUEEZES: &[Stage3TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n" + return Ok(verifier_plan::emit_transcript_squeeze_constants( + "Stage3", + "STAGE3", + &plan.transcript_squeezes, )); } let squeezes = self @@ -1396,25 +1374,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); fn emit_opening_input_constants(&self) -> Result { if self.role == Role::Verifier { let plan = self.verifier_plan()?; - let inputs = plan - .opening_inputs - .iter() - .map(|input| { - format!( - " Stage3OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},", - rust_str(&input.symbol), - rust_str(&input.source_stage), - rust_str(&input.source_claim), - rust_str(&input.oracle), - rust_str(&input.domain), - input.point_arity, - verifier_plan::claim_kind_expr("Stage3", input.claim_kind) - ) - }) - .collect::>() - .join("\n"); - return Ok(format!( - "pub const STAGE3_OPENING_INPUTS: &[Stage3OpeningInputPlan] = &[\n{inputs}\n];\n\n" + return Ok(verifier_plan::emit_opening_input_constants( + "Stage3", + "STAGE3", + &plan.opening_inputs, )); } let inputs = self @@ -1461,21 +1424,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { let plan = self.verifier_plan()?; - let exprs = plan - .field_exprs - .iter() - .map(|expr| { - format!( - " Stage3FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", - rust_str(&expr.symbol), - verifier_plan::field_expr_kind_expr("Stage3", expr.kind), - super::plan_tokens::rust_str_slice_expr(&expr.operands) - ) - }) - .collect::>() - .join("\n"); - return Ok(format!( - "pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[\n{exprs}\n];\n" + return Ok(verifier_plan::emit_field_expr_constants( + "Stage3", + "STAGE3", + &plan.field_exprs, )); } diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 2e340b87e7..19528fb20b 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -260,6 +260,114 @@ pub(crate) fn opening_equality_mode_expr( ) } +pub(crate) fn emit_program_step_constants( + stage_type_prefix: &str, + const_prefix: &str, + steps: &[VerifierProgramStepPlan], +) -> String { + let steps = steps + .iter() + .map(|step| { + format!( + " {stage_type_prefix}ProgramStepPlan {{ kind: {}, symbol: {} }},", + program_step_kind_expr(stage_type_prefix, step.kind), + rust_str(&step.symbol), + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_PROGRAM_STEPS: &[{stage_type_prefix}ProgramStepPlan] = &[\n{steps}\n];\n\n" + ) +} + +pub(crate) fn emit_transcript_squeeze_constants( + stage_type_prefix: &str, + const_prefix: &str, + squeezes: &[VerifierTranscriptSqueezePlan], +) -> String { + let squeezes = squeezes + .iter() + .map(|squeeze| { + format!( + " {stage_type_prefix}TranscriptSqueezePlan {{ symbol: {}, label: {}, kind: {}, count: {} }},", + rust_str(&squeeze.symbol), + rust_str(&squeeze.label), + transcript_squeeze_kind_expr(stage_type_prefix, squeeze.kind), + squeeze.count, + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_TRANSCRIPT_SQUEEZES: &[{stage_type_prefix}TranscriptSqueezePlan] = &[\n{squeezes}\n];\n\n" + ) +} + +pub(crate) fn emit_opening_input_constants( + stage_type_prefix: &str, + const_prefix: &str, + inputs: &[VerifierOpeningInputPlan], +) -> String { + let inputs = inputs + .iter() + .map(|input| { + format!( + " {stage_type_prefix}OpeningInputPlan {{ symbol: {}, source_stage: {}, source_claim: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {} }},", + rust_str(&input.symbol), + rust_str(&input.source_stage), + rust_str(&input.source_claim), + rust_str(&input.oracle), + rust_str(&input.domain), + input.point_arity, + claim_kind_expr(stage_type_prefix, input.claim_kind), + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_OPENING_INPUTS: &[{stage_type_prefix}OpeningInputPlan] = &[\n{inputs}\n];\n\n" + ) +} + +pub(crate) fn emit_field_expr_constants( + stage_type_prefix: &str, + const_prefix: &str, + exprs: &[VerifierFieldExprPlan], +) -> String { + let exprs = exprs + .iter() + .map(|expr| { + format!( + " {stage_type_prefix}FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", + rust_str(&expr.symbol), + field_expr_kind_expr(stage_type_prefix, expr.kind), + rust_str_slice_expr(&expr.operands), + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_FIELD_EXPRS: &[{stage_type_prefix}FieldExprPlan] = &[\n{exprs}\n];\n" + ) +} + +fn rust_str_slice_expr(values: &[String]) -> String { + if values.is_empty() { + return "&[]".to_owned(); + } + let values = values + .iter() + .map(|value| rust_str(value)) + .collect::>() + .join(", "); + format!("&[{values}]") +} + +fn rust_str(value: &str) -> String { + format!("{value:?}") +} + fn missing_plan_row(kind: &'static str, index: usize) -> EmitError { EmitError::new(format!("missing verifier-plan {kind} at index {index}")) } From edc7bb143da44a3cb2b9c6790875cbeb77372722 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 00:56:11 -0600 Subject: [PATCH 060/171] refactor(bolt): complete stage3 verifier plan projection --- .../src/protocols/jolt/emit/rust/stage3.rs | 288 +++++++++--------- .../bolt/src/protocols/jolt/verifier_plan.rs | 288 +++++++++++++----- 2 files changed, 360 insertions(+), 216 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index a529fd56a8..a7ed40e6a7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -608,7 +608,7 @@ impl Stage3CpuProgram { .map(|step| { verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) }) - .collect::, _>>()?, + .collect::, EmitError>>()?, transcript_squeezes: self .transcript_squeezes .iter() @@ -620,7 +620,7 @@ impl Stage3CpuProgram { squeeze.count, ) }) - .collect::, _>>()?, + .collect::, EmitError>>()?, opening_inputs: self .opening_inputs .iter() @@ -635,7 +635,7 @@ impl Stage3CpuProgram { &input.claim_kind, ) }) - .collect::, _>>()?, + .collect::, EmitError>>()?, field_exprs: self .field_exprs .iter() @@ -646,43 +646,97 @@ impl Stage3CpuProgram { &expr.operands, ) }) - .collect::, _>>()?, + .collect::, EmitError>>()?, claims: self .claims .iter() .map(|claim| { - verifier_plan::VerifierSumcheckClaimPlan::from_cpu(claim.relation.as_deref()) + Ok(verifier_plan::VerifierSumcheckClaimPlan { + symbol: claim.symbol.clone(), + stage: claim.stage.clone(), + domain: claim.domain.clone(), + num_rounds: claim.num_rounds, + degree: claim.degree, + claim: claim.claim.clone(), + relation: verifier_plan::required_relation_from_cpu( + claim.relation.as_deref(), + "claim", + &claim.symbol, + )?, + claim_value: claim.claim_value.clone(), + }) }) - .collect::, _>>()?, + .collect::, EmitError>>()?, drivers: self .drivers .iter() .map(|driver| { - verifier_plan::VerifierSumcheckDriverPlan::from_cpu(driver.relation.as_deref()) + Ok(verifier_plan::VerifierSumcheckDriverPlan { + symbol: driver.symbol.clone(), + stage: driver.stage.clone(), + proof_slot: driver.proof_slot.clone(), + relation: verifier_plan::required_relation_from_cpu( + driver.relation.as_deref(), + "driver", + &driver.symbol, + )?, + batch: driver.batch.clone(), + policy: driver.policy.clone(), + round_schedule: driver.round_schedule.clone(), + claim_label: driver.claim_label.clone(), + round_label: driver.round_label.clone(), + num_rounds: driver.num_rounds, + degree: driver.degree, + }) }) - .collect::, _>>()?, + .collect::, EmitError>>()?, instance_results: self .instance_results .iter() .map(|instance| { - verifier_plan::VerifierSumcheckInstanceResultPlan::from_cpu( - &instance.relation, - &instance.point_order, - ) + Ok(verifier_plan::VerifierSumcheckInstanceResultPlan { + symbol: instance.symbol.clone(), + source: instance.source.clone(), + claim: instance.claim.clone(), + relation: verifier_plan::relation_from_cpu(&instance.relation)?, + index: instance.index, + point_arity: instance.point_arity, + num_rounds: instance.num_rounds, + round_offset: instance.round_offset, + point_order: verifier_plan::sumcheck_point_order_from_cpu( + &instance.point_order, + )?, + degree: instance.degree, + }) }) - .collect::, _>>()?, + .collect::, EmitError>>()?, opening_claims: self .opening_claims .iter() - .map(|claim| verifier_plan::VerifierOpeningClaimPlan::from_cpu(&claim.claim_kind)) - .collect::, _>>()?, + .map(|claim| { + Ok(verifier_plan::VerifierOpeningClaimPlan { + symbol: claim.symbol.clone(), + oracle: claim.oracle.clone(), + domain: claim.domain.clone(), + point_arity: claim.point_arity, + claim_kind: verifier_plan::claim_kind_from_cpu(&claim.claim_kind)?, + point_source: claim.point_source.clone(), + eval_source: claim.eval_source.clone(), + }) + }) + .collect::, EmitError>>()?, opening_equalities: self .opening_equalities .iter() .map(|equality| { - verifier_plan::VerifierOpeningClaimEqualityPlan::from_cpu(&equality.mode) + Ok(verifier_plan::VerifierOpeningClaimEqualityPlan { + symbol: equality.symbol.clone(), + mode: verifier_plan::opening_equality_mode_from_cpu(&equality.mode)?, + lhs: equality.lhs.clone(), + rhs: equality.rhs.clone(), + }) }) - .collect::, _>>()?, + .collect::, EmitError>>()?, }) } @@ -1501,23 +1555,28 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_sumcheck_claim_constants(&self, prover: bool) -> Result { + if !prover { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_claim_constants( + "Stage3", + "STAGE3", + &plan.claims, + )); + } let mut source = String::new(); - if prover { - for (index, claim) in self.claims.iter().enumerate() { - source.push_str(&emit_str_array( - &format!("STAGE3_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS"), - &claim.input_openings, - )); - } + for (index, claim) in self.claims.iter().enumerate() { + source.push_str(&emit_str_array( + &format!("STAGE3_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS"), + &claim.input_openings, + )); } let mut claims = Vec::new(); for (index, claim) in self.claims.iter().enumerate() { - if prover { - let kernel = claim - .kernel - .as_deref() - .ok_or_else(|| missing_role_binding("prover claim kernel", &claim.symbol))?; - claims.push(format!( + let kernel = claim + .kernel + .as_deref() + .ok_or_else(|| missing_role_binding("prover claim kernel", &claim.symbol))?; + claims.push(format!( " Stage3SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: Some({}), relation: None, claim_value: {}, input_openings: STAGE3_SUMCHECK_CLAIM_{index}_INPUT_OPENINGS }},", rust_str(&claim.symbol), rust_str(&claim.stage), @@ -1528,20 +1587,6 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); rust_str(kernel), rust_str(&claim.claim_value) )); - } else { - let relation = self.verifier_plan()?.claim_relation(index)?; - claims.push(format!( - " Stage3SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {} }},", - rust_str(&claim.symbol), - rust_str(&claim.stage), - rust_str(&claim.domain), - claim.num_rounds, - claim.degree, - rust_str(&claim.claim), - verifier_plan::relation_kind_expr("Stage3", relation), - rust_str(&claim.claim_value) - )); - } } let claims = claims.join("\n"); push_format( @@ -1641,6 +1686,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_sumcheck_driver_constants(&self, prover: bool) -> Result { + if !prover { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_driver_constants( + "Stage3", + "STAGE3", + &plan.drivers, + )); + } let mut source = String::new(); for (index, driver) in self.drivers.iter().enumerate() { source.push_str(&emit_usize_array( @@ -1650,12 +1703,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } let mut drivers = Vec::new(); for (index, driver) in self.drivers.iter().enumerate() { - if prover { - let kernel = driver - .kernel - .as_deref() - .ok_or_else(|| missing_role_binding("prover driver kernel", &driver.symbol))?; - drivers.push(format!( + let kernel = driver + .kernel + .as_deref() + .ok_or_else(|| missing_role_binding("prover driver kernel", &driver.symbol))?; + drivers.push(format!( " Stage3SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: Some({}), relation: None, batch: {}, policy: {}, round_schedule: STAGE3_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},", rust_str(&driver.symbol), rust_str(&driver.stage), @@ -1668,22 +1720,6 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); driver.num_rounds, driver.degree )); - } else { - let relation = self.verifier_plan()?.driver_relation(index)?; - drivers.push(format!( - " Stage3SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: None, relation: Some({}), batch: {}, policy: {}, round_schedule: STAGE3_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},", - rust_str(&driver.symbol), - rust_str(&driver.stage), - rust_str(&driver.proof_slot), - verifier_plan::relation_kind_expr("Stage3", relation), - rust_str(&driver.batch), - rust_str(&driver.policy), - rust_str(&driver.claim_label), - rust_str(&driver.round_label), - driver.num_rounds, - driver.degree - )); - } } let drivers = drivers.join("\n"); push_format( @@ -1708,54 +1744,36 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_sumcheck_instance_result_constants(&self) -> Result { - let verifier_plan = if self.role == Role::Verifier { - Some(self.verifier_plan()?) - } else { - None - }; + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_instance_result_constants( + "Stage3", + "STAGE3", + &plan.instance_results, + )); + } let instances = self .instance_results .iter() - .enumerate() - .map(|(index, instance)| { - let relation = verifier_plan - .and_then(|plan| plan.instance_results.get(index)) - .map_or_else( - || { - super::plan_tokens::role_relation_kind_expr( - "Stage3", - &self.role, - &instance.relation, - ) - }, - |planned| { - Ok(verifier_plan::relation_kind_expr("Stage3", planned.relation)) - }, - )?; - let point_order = verifier_plan - .and_then(|plan| plan.instance_results.get(index)) - .map_or_else( - || { - super::plan_tokens::role_sumcheck_point_order_expr( - &self.role, - &instance.point_order, - ) - }, - |planned| { - Ok(verifier_plan::sumcheck_point_order_expr(planned.point_order)) - }, - )?; + .map(|instance| { Ok(format!( " Stage3SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},", rust_str(&instance.symbol), rust_str(&instance.source), rust_str(&instance.claim), - relation, + super::plan_tokens::role_relation_kind_expr( + "Stage3", + &self.role, + &instance.relation + )?, instance.index, instance.point_arity, instance.num_rounds, instance.round_offset, - point_order, + super::plan_tokens::role_sumcheck_point_order_expr( + &self.role, + &instance.point_order + )?, instance.degree )) }) @@ -1864,35 +1882,25 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_opening_claim_constants(&self) -> Result { - let verifier_plan = if self.role == Role::Verifier { - Some(self.verifier_plan()?) - } else { - None - }; + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_claim_constants( + "Stage3", + "STAGE3", + &plan.opening_claims, + )); + } let claims = self .opening_claims .iter() - .enumerate() - .map(|(index, claim)| { - let claim_kind = verifier_plan - .and_then(|plan| plan.opening_claims.get(index)) - .map_or_else( - || { - super::plan_tokens::role_claim_kind_expr( - "Stage3", - &self.role, - &claim.claim_kind, - ) - }, - |planned| Ok(verifier_plan::claim_kind_expr("Stage3", planned.claim_kind)), - )?; + .map(|claim| { Ok(format!( " Stage3OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},", rust_str(&claim.symbol), rust_str(&claim.oracle), rust_str(&claim.domain), claim.point_arity, - claim_kind, + super::plan_tokens::role_claim_kind_expr("Stage3", &self.role, &claim.claim_kind)?, rust_str(&claim.point_source), rust_str(&claim.eval_source) )) @@ -1905,34 +1913,26 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); } fn emit_opening_claim_equality_constants(&self) -> Result { - let verifier_plan = if self.role == Role::Verifier { - Some(self.verifier_plan()?) - } else { - None - }; + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_claim_equality_constants( + "Stage3", + "STAGE3", + &plan.opening_equalities, + )); + } let equalities = self .opening_equalities .iter() - .enumerate() - .map(|(index, equality)| { - let mode = verifier_plan - .and_then(|plan| plan.opening_equalities.get(index)) - .map_or_else( - || { - super::plan_tokens::role_opening_equality_mode_expr( - "Stage3", - &self.role, - &equality.mode, - ) - }, - |planned| { - Ok(verifier_plan::opening_equality_mode_expr("Stage3", planned.mode)) - }, - )?; + .map(|equality| { Ok(format!( " Stage3OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},", rust_str(&equality.symbol), - mode, + super::plan_tokens::role_opening_equality_mode_expr( + "Stage3", + &self.role, + &equality.mode + )?, rust_str(&equality.lhs), rust_str(&equality.rhs) )) diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 19528fb20b..91d74326c7 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -1,3 +1,5 @@ +use std::fmt::Write as _; + use crate::emit::rust::EmitError; use crate::protocols::jolt::rust_target_plan::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, ProgramStepKind, @@ -99,75 +101,62 @@ impl VerifierFieldExprPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierSumcheckClaimPlan { - pub(crate) relation: Option, -} - -impl VerifierSumcheckClaimPlan { - pub(crate) fn from_cpu(relation: Option<&str>) -> Result { - Ok(Self { - relation: relation - .map(JoltVerifierRelationKind::from_cpu_attr) - .transpose() - .map_err(plan_error)?, - }) - } + pub(crate) symbol: String, + pub(crate) stage: String, + pub(crate) domain: String, + pub(crate) num_rounds: usize, + pub(crate) degree: usize, + pub(crate) claim: String, + pub(crate) relation: JoltVerifierRelationKind, + pub(crate) claim_value: String, } #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierSumcheckDriverPlan { - pub(crate) relation: Option, -} - -impl VerifierSumcheckDriverPlan { - pub(crate) fn from_cpu(relation: Option<&str>) -> Result { - Ok(Self { - relation: relation - .map(JoltVerifierRelationKind::from_cpu_attr) - .transpose() - .map_err(plan_error)?, - }) - } + pub(crate) symbol: String, + pub(crate) stage: String, + pub(crate) proof_slot: String, + pub(crate) relation: JoltVerifierRelationKind, + pub(crate) batch: String, + pub(crate) policy: String, + pub(crate) round_schedule: Vec, + pub(crate) claim_label: String, + pub(crate) round_label: String, + pub(crate) num_rounds: usize, + pub(crate) degree: usize, } #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierSumcheckInstanceResultPlan { + pub(crate) symbol: String, + pub(crate) source: String, + pub(crate) claim: String, pub(crate) relation: JoltVerifierRelationKind, + pub(crate) index: usize, + pub(crate) point_arity: usize, + pub(crate) num_rounds: usize, + pub(crate) round_offset: usize, pub(crate) point_order: SumcheckPointOrder, -} - -impl VerifierSumcheckInstanceResultPlan { - pub(crate) fn from_cpu(relation: &str, point_order: &str) -> Result { - Ok(Self { - relation: JoltVerifierRelationKind::from_cpu_attr(relation).map_err(plan_error)?, - point_order: SumcheckPointOrder::from_cpu_attr(point_order).map_err(plan_error)?, - }) - } + pub(crate) degree: usize, } #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierOpeningClaimPlan { + pub(crate) symbol: String, + pub(crate) oracle: String, + pub(crate) domain: String, + pub(crate) point_arity: usize, pub(crate) claim_kind: ClaimKind, -} - -impl VerifierOpeningClaimPlan { - pub(crate) fn from_cpu(claim_kind: &str) -> Result { - Ok(Self { - claim_kind: ClaimKind::from_cpu_attr(claim_kind).map_err(plan_error)?, - }) - } + pub(crate) point_source: String, + pub(crate) eval_source: String, } #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierOpeningClaimEqualityPlan { + pub(crate) symbol: String, pub(crate) mode: OpeningEqualityMode, -} - -impl VerifierOpeningClaimEqualityPlan { - pub(crate) fn from_cpu(mode: &str) -> Result { - Ok(Self { - mode: OpeningEqualityMode::from_cpu_attr(mode).map_err(plan_error)?, - }) - } + pub(crate) lhs: String, + pub(crate) rhs: String, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -183,26 +172,32 @@ pub(crate) struct VerifierStagePlan { pub(crate) opening_equalities: Vec, } -impl VerifierStagePlan { - pub(crate) fn claim_relation( - &self, - index: usize, - ) -> Result { - self.claims - .get(index) - .and_then(|claim| claim.relation) - .ok_or_else(|| missing_plan_row("claim relation", index)) - } +pub(crate) fn relation_from_cpu(value: &str) -> Result { + JoltVerifierRelationKind::from_cpu_attr(value).map_err(plan_error) +} - pub(crate) fn driver_relation( - &self, - index: usize, - ) -> Result { - self.drivers - .get(index) - .and_then(|driver| driver.relation) - .ok_or_else(|| missing_plan_row("driver relation", index)) - } +pub(crate) fn required_relation_from_cpu( + value: Option<&str>, + kind: &str, + symbol: &str, +) -> Result { + value + .ok_or_else(|| EmitError::new(format!("missing verifier {kind} relation for `{symbol}`"))) + .and_then(relation_from_cpu) +} + +pub(crate) fn claim_kind_from_cpu(value: &str) -> Result { + ClaimKind::from_cpu_attr(value).map_err(plan_error) +} + +pub(crate) fn sumcheck_point_order_from_cpu(value: &str) -> Result { + SumcheckPointOrder::from_cpu_attr(value).map_err(plan_error) +} + +pub(crate) fn opening_equality_mode_from_cpu( + value: &str, +) -> Result { + OpeningEqualityMode::from_cpu_attr(value).map_err(plan_error) } pub(crate) fn relation_kind_expr( @@ -352,6 +347,159 @@ pub(crate) fn emit_field_expr_constants( ) } +pub(crate) fn emit_sumcheck_claim_constants( + stage_type_prefix: &str, + const_prefix: &str, + claims: &[VerifierSumcheckClaimPlan], +) -> String { + let claims = claims + .iter() + .map(|claim| { + format!( + " {stage_type_prefix}SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: None, relation: Some({}), claim_value: {} }},", + rust_str(&claim.symbol), + rust_str(&claim.stage), + rust_str(&claim.domain), + claim.num_rounds, + claim.degree, + rust_str(&claim.claim), + relation_kind_expr(stage_type_prefix, claim.relation), + rust_str(&claim.claim_value), + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_SUMCHECK_CLAIMS: &[{stage_type_prefix}SumcheckClaimPlan] = &[\n{claims}\n];\n" + ) +} + +pub(crate) fn emit_sumcheck_driver_constants( + stage_type_prefix: &str, + const_prefix: &str, + drivers: &[VerifierSumcheckDriverPlan], +) -> String { + let mut source = String::new(); + for (index, driver) in drivers.iter().enumerate() { + source.push_str(&emit_usize_array( + &format!("{const_prefix}_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE"), + &driver.round_schedule, + )); + } + let drivers = drivers + .iter() + .enumerate() + .map(|(index, driver)| { + format!( + " {stage_type_prefix}SumcheckDriverPlan {{ symbol: {}, stage: {}, proof_slot: {}, kernel: None, relation: Some({}), batch: {}, policy: {}, round_schedule: {const_prefix}_SUMCHECK_DRIVER_{index}_ROUND_SCHEDULE, claim_label: {}, round_label: {}, num_rounds: {}, degree: {} }},", + rust_str(&driver.symbol), + rust_str(&driver.stage), + rust_str(&driver.proof_slot), + relation_kind_expr(stage_type_prefix, driver.relation), + rust_str(&driver.batch), + rust_str(&driver.policy), + rust_str(&driver.claim_label), + rust_str(&driver.round_label), + driver.num_rounds, + driver.degree, + ) + }) + .collect::>() + .join("\n"); + let _ = write!( + source, + "pub const {const_prefix}_SUMCHECK_DRIVERS: &[{stage_type_prefix}SumcheckDriverPlan] = &[\n{drivers}\n];\n" + ); + source +} + +pub(crate) fn emit_sumcheck_instance_result_constants( + stage_type_prefix: &str, + const_prefix: &str, + instances: &[VerifierSumcheckInstanceResultPlan], +) -> String { + let instances = instances + .iter() + .map(|instance| { + format!( + " {stage_type_prefix}SumcheckInstanceResultPlan {{ symbol: {}, source: {}, claim: {}, relation: {}, index: {}, point_arity: {}, num_rounds: {}, round_offset: {}, point_order: {}, degree: {} }},", + rust_str(&instance.symbol), + rust_str(&instance.source), + rust_str(&instance.claim), + relation_kind_expr(stage_type_prefix, instance.relation), + instance.index, + instance.point_arity, + instance.num_rounds, + instance.round_offset, + sumcheck_point_order_expr(instance.point_order), + instance.degree, + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_SUMCHECK_INSTANCE_RESULTS: &[{stage_type_prefix}SumcheckInstanceResultPlan] = &[\n{instances}\n];\n\n" + ) +} + +pub(crate) fn emit_opening_claim_constants( + stage_type_prefix: &str, + const_prefix: &str, + claims: &[VerifierOpeningClaimPlan], +) -> String { + let claims = claims + .iter() + .map(|claim| { + format!( + " {stage_type_prefix}OpeningClaimPlan {{ symbol: {}, oracle: {}, domain: {}, point_arity: {}, claim_kind: {}, point_source: {}, eval_source: {} }},", + rust_str(&claim.symbol), + rust_str(&claim.oracle), + rust_str(&claim.domain), + claim.point_arity, + claim_kind_expr(stage_type_prefix, claim.claim_kind), + rust_str(&claim.point_source), + rust_str(&claim.eval_source), + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_OPENING_CLAIMS: &[{stage_type_prefix}OpeningClaimPlan] = &[\n{claims}\n];\n\n" + ) +} + +pub(crate) fn emit_opening_claim_equality_constants( + stage_type_prefix: &str, + const_prefix: &str, + equalities: &[VerifierOpeningClaimEqualityPlan], +) -> String { + let equalities = equalities + .iter() + .map(|equality| { + format!( + " {stage_type_prefix}OpeningClaimEqualityPlan {{ symbol: {}, mode: {}, lhs: {}, rhs: {} }},", + rust_str(&equality.symbol), + opening_equality_mode_expr(stage_type_prefix, equality.mode), + rust_str(&equality.lhs), + rust_str(&equality.rhs), + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_OPENING_EQUALITIES: &[{stage_type_prefix}OpeningClaimEqualityPlan] = &[\n{equalities}\n];\n\n" + ) +} + +fn emit_usize_array(name: &str, values: &[usize]) -> String { + let entries = values + .iter() + .map(usize::to_string) + .collect::>() + .join(", "); + format!("pub const {name}: &[usize] = &[{entries}];\n\n") +} + fn rust_str_slice_expr(values: &[String]) -> String { if values.is_empty() { return "&[]".to_owned(); @@ -368,10 +516,6 @@ fn rust_str(value: &str) -> String { format!("{value:?}") } -fn missing_plan_row(kind: &'static str, index: usize) -> EmitError { - EmitError::new(format!("missing verifier-plan {kind} at index {index}")) -} - fn plan_error(error: RustTargetPlanError) -> EmitError { EmitError::new(error.to_string()) } From 74edf5dbefab7cae38e3c667e6fa0c55c74b061a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 01:02:27 -0600 Subject: [PATCH 061/171] refactor(bolt): project stage4 verifier plan --- .../src/protocols/jolt/emit/rust/stage3.rs | 1 + .../src/protocols/jolt/emit/rust/stage4.rs | 293 +++++++++++++++--- .../bolt/src/protocols/jolt/verifier_plan.rs | 40 +++ 3 files changed, 285 insertions(+), 49 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index a7ed40e6a7..cbf9c236e1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -621,6 +621,7 @@ impl Stage3CpuProgram { ) }) .collect::, EmitError>>()?, + transcript_absorb_bytes: Vec::new(), opening_inputs: self .opening_inputs .iter() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 6c9fbfa297..7d3743f003 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -17,11 +17,13 @@ use super::output_claims::{ }; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage4CpuProgram { pub role: Role, + pub(crate) verifier_plan: Option, pub params: Stage4Params, pub steps: Vec, pub transcript_squeezes: Vec, @@ -556,6 +558,7 @@ impl Stage4CpuProgram { let role = module .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; + let is_verifier = role == Role::Verifier; if role == Role::Prover { super::output_claims::prune_output_only_field_exprs( &mut field_exprs, @@ -579,9 +582,10 @@ impl Stage4CpuProgram { Vec::new() }; - Ok(Self { + let mut program = Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, role, + verifier_plan: None, steps, transcript_squeezes, transcript_absorb_bytes, @@ -601,9 +605,170 @@ impl Stage4CpuProgram { opening_claims, opening_equalities, opening_batches, + }; + if is_verifier { + program.verifier_plan = Some(program.plan_verifier()?); + } + Ok(program) + } + + fn plan_verifier(&self) -> Result { + Ok(VerifierStagePlan { + steps: self + .steps + .iter() + .map(|step| { + verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) + }) + .collect::, EmitError>>()?, + transcript_squeezes: self + .transcript_squeezes + .iter() + .map(|squeeze| { + verifier_plan::VerifierTranscriptSqueezePlan::from_cpu( + &squeeze.symbol, + &squeeze.label, + &squeeze.kind, + squeeze.count, + ) + }) + .collect::, EmitError>>()?, + transcript_absorb_bytes: self + .transcript_absorb_bytes + .iter() + .map(|absorb| { + verifier_plan::VerifierTranscriptAbsorbBytesPlan::from_cpu( + &absorb.symbol, + &absorb.label, + &absorb.payload, + ) + }) + .collect(), + opening_inputs: self + .opening_inputs + .iter() + .map(|input| { + verifier_plan::VerifierOpeningInputPlan::from_cpu( + &input.symbol, + &input.source_stage, + &input.source_claim, + &input.oracle, + &input.domain, + input.point_arity, + &input.claim_kind, + ) + }) + .collect::, EmitError>>()?, + field_exprs: self + .field_exprs + .iter() + .map(|expr| { + verifier_plan::VerifierFieldExprPlan::from_cpu( + &expr.symbol, + &expr.formula, + &expr.operands, + ) + }) + .collect::, EmitError>>()?, + claims: self + .claims + .iter() + .map(|claim| { + Ok(verifier_plan::VerifierSumcheckClaimPlan { + symbol: claim.symbol.clone(), + stage: claim.stage.clone(), + domain: claim.domain.clone(), + num_rounds: claim.num_rounds, + degree: claim.degree, + claim: claim.claim.clone(), + relation: verifier_plan::required_relation_from_cpu( + claim.relation.as_deref(), + "claim", + &claim.symbol, + )?, + claim_value: claim.claim_value.clone(), + }) + }) + .collect::, EmitError>>()?, + drivers: self + .drivers + .iter() + .map(|driver| { + Ok(verifier_plan::VerifierSumcheckDriverPlan { + symbol: driver.symbol.clone(), + stage: driver.stage.clone(), + proof_slot: driver.proof_slot.clone(), + relation: verifier_plan::required_relation_from_cpu( + driver.relation.as_deref(), + "driver", + &driver.symbol, + )?, + batch: driver.batch.clone(), + policy: driver.policy.clone(), + round_schedule: driver.round_schedule.clone(), + claim_label: driver.claim_label.clone(), + round_label: driver.round_label.clone(), + num_rounds: driver.num_rounds, + degree: driver.degree, + }) + }) + .collect::, EmitError>>()?, + instance_results: self + .instance_results + .iter() + .map(|instance| { + Ok(verifier_plan::VerifierSumcheckInstanceResultPlan { + symbol: instance.symbol.clone(), + source: instance.source.clone(), + claim: instance.claim.clone(), + relation: verifier_plan::relation_from_cpu(&instance.relation)?, + index: instance.index, + point_arity: instance.point_arity, + num_rounds: instance.num_rounds, + round_offset: instance.round_offset, + point_order: verifier_plan::sumcheck_point_order_from_cpu( + &instance.point_order, + )?, + degree: instance.degree, + }) + }) + .collect::, EmitError>>()?, + opening_claims: self + .opening_claims + .iter() + .map(|claim| { + Ok(verifier_plan::VerifierOpeningClaimPlan { + symbol: claim.symbol.clone(), + oracle: claim.oracle.clone(), + domain: claim.domain.clone(), + point_arity: claim.point_arity, + claim_kind: verifier_plan::claim_kind_from_cpu(&claim.claim_kind)?, + point_source: claim.point_source.clone(), + eval_source: claim.eval_source.clone(), + }) + }) + .collect::, EmitError>>()?, + opening_equalities: self + .opening_equalities + .iter() + .map(|equality| { + Ok(verifier_plan::VerifierOpeningClaimEqualityPlan { + symbol: equality.symbol.clone(), + mode: verifier_plan::opening_equality_mode_from_cpu(&equality.mode)?, + lhs: equality.lhs.clone(), + rhs: equality.rhs.clone(), + }) + }) + .collect::, EmitError>>()?, }) } + fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { + self.verifier_plan + .as_ref() + .ok_or_else(|| EmitError::new("missing stage4 verifier plan")) + } + fn verify_supported_target(&self) -> Result<(), EmitError> { require_supported_symbol("field", &self.params.field, "bn254_fr")?; require_supported_symbol("pcs", &self.params.pcs, "dory")?; @@ -1416,7 +1581,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); ); source.push_str(&self.emit_program_step_constants()?); source.push_str(&self.emit_transcript_squeeze_constants()?); - source.push_str(&self.emit_transcript_absorb_bytes_constants()); + source.push_str(&self.emit_transcript_absorb_bytes_constants()?); source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); @@ -1424,6 +1589,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } fn emit_program_step_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_program_step_constants( + "Stage4", + "STAGE4", + &plan.steps, + )); + } let steps = self .steps .iter() @@ -1444,6 +1617,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } fn emit_transcript_squeeze_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_transcript_squeeze_constants( + "Stage4", + "STAGE4", + &plan.transcript_squeezes, + )); + } let squeezes = self .transcript_squeezes .iter() @@ -1463,7 +1644,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); )) } - fn emit_transcript_absorb_bytes_constants(&self) -> String { + fn emit_transcript_absorb_bytes_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_transcript_absorb_bytes_constants( + "Stage4", + "STAGE4", + &plan.transcript_absorb_bytes, + )); + } let absorbs = self .transcript_absorb_bytes .iter() @@ -1477,12 +1666,20 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); }) .collect::>() .join("\n"); - format!( + Ok(format!( "pub const STAGE4_TRANSCRIPT_ABSORB_BYTES: &[Stage4TranscriptAbsorbBytesPlan] = &[\n{absorbs}\n];\n\n" - ) + )) } fn emit_opening_input_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_input_constants( + "Stage4", + "STAGE4", + &plan.opening_inputs, + )); + } let inputs = self .opening_inputs .iter() @@ -1526,25 +1723,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { - let exprs = self - .field_exprs - .iter() - .map(|expr| { - Ok(format!( - " Stage4FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", - rust_str(&expr.symbol), - super::plan_tokens::role_field_expr_kind_expr( - "Stage4", - &self.role, - &expr.formula - )?, - super::plan_tokens::rust_str_slice_expr(&expr.operands) - )) - }) - .collect::, EmitError>>()? - .join("\n"); - return Ok(format!( - "pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[\n{exprs}\n];\n" + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_field_expr_constants( + "Stage4", + "STAGE4", + &plan.field_exprs, )); } @@ -1611,31 +1794,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); fn emit_sumcheck_claim_constants(&self) -> Result { if self.role == Role::Verifier { - let claims = self - .claims - .iter() - .map(|claim| { - Ok(format!( - " Stage4SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {} }},", - rust_str(&claim.symbol), - rust_str(&claim.stage), - rust_str(&claim.domain), - claim.num_rounds, - claim.degree, - rust_str(&claim.claim), - rust_option_str(claim.kernel.as_deref()), - super::plan_tokens::role_optional_relation_kind_expr( - "Stage4", - &self.role, - claim.relation.as_deref() - )?, - rust_str(&claim.claim_value) - )) - }) - .collect::, EmitError>>()? - .join("\n"); - return Ok(format!( - "pub const STAGE4_SUMCHECK_CLAIMS: &[Stage4SumcheckClaimPlan] = &[\n{claims}\n];\n" + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_claim_constants( + "Stage4", + "STAGE4", + &plan.claims, )); } @@ -1759,6 +1922,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } fn emit_sumcheck_driver_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_driver_constants( + "Stage4", + "STAGE4", + &plan.drivers, + )); + } let mut source = String::new(); for (index, driver) in self.drivers.iter().enumerate() { source.push_str(&emit_usize_array( @@ -1814,6 +1985,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } fn emit_sumcheck_instance_result_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_instance_result_constants( + "Stage4", + "STAGE4", + &plan.instance_results, + )); + } let instances = self .instance_results .iter() @@ -1944,6 +2123,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } fn emit_opening_claim_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_claim_constants( + "Stage4", + "STAGE4", + &plan.opening_claims, + )); + } let claims = self .opening_claims .iter() @@ -1967,6 +2154,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } fn emit_opening_claim_equality_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_claim_equality_constants( + "Stage4", + "STAGE4", + &plan.opening_equalities, + )); + } let equalities = self .opening_equalities .iter() diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 91d74326c7..33b1544d25 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -45,6 +45,23 @@ impl VerifierTranscriptSqueezePlan { } } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierTranscriptAbsorbBytesPlan { + pub(crate) symbol: String, + pub(crate) label: String, + pub(crate) payload: String, +} + +impl VerifierTranscriptAbsorbBytesPlan { + pub(crate) fn from_cpu(symbol: &str, label: &str, payload: &str) -> Self { + Self { + symbol: symbol.to_owned(), + label: label.to_owned(), + payload: payload.to_owned(), + } + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierOpeningInputPlan { pub(crate) symbol: String, @@ -163,6 +180,7 @@ pub(crate) struct VerifierOpeningClaimEqualityPlan { pub(crate) struct VerifierStagePlan { pub(crate) steps: Vec, pub(crate) transcript_squeezes: Vec, + pub(crate) transcript_absorb_bytes: Vec, pub(crate) opening_inputs: Vec, pub(crate) field_exprs: Vec, pub(crate) claims: Vec, @@ -299,6 +317,28 @@ pub(crate) fn emit_transcript_squeeze_constants( ) } +pub(crate) fn emit_transcript_absorb_bytes_constants( + stage_type_prefix: &str, + const_prefix: &str, + absorbs: &[VerifierTranscriptAbsorbBytesPlan], +) -> String { + let absorbs = absorbs + .iter() + .map(|absorb| { + format!( + " {stage_type_prefix}TranscriptAbsorbBytesPlan {{ symbol: {}, label: {}, payload: {} }},", + rust_str(&absorb.symbol), + rust_str(&absorb.label), + rust_str(&absorb.payload), + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_TRANSCRIPT_ABSORB_BYTES: &[{stage_type_prefix}TranscriptAbsorbBytesPlan] = &[\n{absorbs}\n];\n\n" + ) +} + pub(crate) fn emit_opening_input_constants( stage_type_prefix: &str, const_prefix: &str, From 015a78eda8ebc978af151a12e5e9a6d3f693ddbf Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 01:08:24 -0600 Subject: [PATCH 062/171] refactor(bolt): move verifier output claim planning --- .../protocols/jolt/emit/rust/output_claims.rs | 1109 +---------------- .../src/protocols/jolt/emit/rust/stage3.rs | 17 +- .../src/protocols/jolt/emit/rust/stage4.rs | 17 +- .../src/protocols/jolt/emit/rust/stage5.rs | 17 +- .../src/protocols/jolt/emit/rust/stage6.rs | 18 +- .../src/protocols/jolt/emit/rust/stage7.rs | 16 +- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../protocols/jolt/verifier_output_claims.rs | 1105 ++++++++++++++++ 8 files changed, 1154 insertions(+), 1146 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_output_claims.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index ffb9c88ff8..b1df6ea39b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -1,695 +1,8 @@ -use std::collections::{BTreeMap, BTreeSet}; - -use melior::ir::operation::{OperationLike, OperationResult}; -use melior::ir::{Attribute, OperationRef}; - use crate::emit::rust::{push_format, EmitError}; -use crate::ir::{string_attribute_value, Role}; -use crate::schema::operation_name; - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct StructuredPolynomialPointPlan { - pub source: String, - pub segment: String, - pub length: String, - pub order: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct StructuredPolynomialEvalPlan { - pub symbol: String, - pub polynomial: String, - pub x_point: StructuredPolynomialPointPlan, - pub y_point: StructuredPolynomialPointPlan, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputEvalFamilySharedTermPlan { - pub gamma_power_offset: usize, - pub factor: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputEvalFamilyItemTermPlan { - pub gamma_power_offset: usize, - pub factors: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputEvalFamilyPlan { - pub symbol: String, - pub gamma: String, - pub evals: Vec, - pub power_stride: usize, - pub value_term_offsets: Vec, - pub shared_terms: Vec, - pub item_terms: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputProductFamilyTermPlan { - pub gamma_power_offset: usize, - pub evals: Vec, - pub factors: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputProductFamilyPlan { - pub symbol: String, - pub gamma: Option, - pub terms: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputFunctionFamilyTermPlan { - pub gamma_power_offset: usize, - pub function: String, - pub eval: String, - pub factors: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputFunctionFamilyPlan { - pub symbol: String, - pub gamma: Option, - pub terms: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputClaimPlan { - pub relation: String, - pub polynomial_evals: Vec, - pub eval_families: Vec, - pub product_families: Vec, - pub function_families: Vec, - pub claim_value: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputClaimAst { - pub relation: String, - pub polynomial_evals: Vec, - pub polynomial_eval_operands: Vec, - pub claim_value: String, -} - -pub fn parse_output_eval_family_plan( - stage: &str, - operation: OperationRef<'_, '_>, -) -> Result { - let symbol = string_attr(operation, "sym_name")?; - let evals = symbol_array_attr(operation, "evals")?; - let shared_factors = symbol_array_attr(operation, "shared_terms")?; - let item_factors = symbol_array_attr(operation, "item_terms")?; - let value_term_offsets = int_array_attr(operation, "value_term_offsets")?; - let shared_term_offsets = int_array_attr(operation, "shared_term_offsets")?; - let item_term_offsets = int_array_attr(operation, "item_term_offsets")?; - verify_count( - "output eval family shared terms", - &symbol, - shared_term_offsets.len(), - shared_factors.len(), - )?; - verify_count( - "output eval family item term factors", - &symbol, - item_term_offsets.len() * evals.len(), - item_factors.len(), - )?; - let gamma = operand_symbol(operation, 0)?; - let eval_operands = operand_symbols(operation, 1, 1 + evals.len())?; - if evals != eval_operands { - return Err(EmitError::new(format!( - "{stage} output eval family @{symbol} evals do not match operands" - ))); - } - let shared_start = 1 + evals.len(); - let shared_end = shared_start + shared_factors.len(); - let shared_operands = operand_symbols(operation, shared_start, shared_end)?; - if shared_factors != shared_operands { - return Err(EmitError::new(format!( - "{stage} output eval family @{symbol} shared_terms do not match operands" - ))); - } - let item_operands = operand_symbols(operation, shared_end, operation.operand_count())?; - if item_factors != item_operands { - return Err(EmitError::new(format!( - "{stage} output eval family @{symbol} item_terms do not match operands" - ))); - } - let shared_terms = shared_term_offsets - .into_iter() - .zip(shared_factors) - .map( - |(gamma_power_offset, factor)| SumcheckOutputEvalFamilySharedTermPlan { - gamma_power_offset, - factor, - }, - ) - .collect(); - let mut item_terms = Vec::with_capacity(item_term_offsets.len()); - for (term_index, gamma_power_offset) in item_term_offsets.into_iter().enumerate() { - let start = term_index * evals.len(); - let end = start + evals.len(); - item_terms.push(SumcheckOutputEvalFamilyItemTermPlan { - gamma_power_offset, - factors: item_factors[start..end].to_vec(), - }); - } - Ok(SumcheckOutputEvalFamilyPlan { - symbol, - gamma, - evals, - power_stride: int_attr(operation, "power_stride")?, - value_term_offsets, - shared_terms, - item_terms, - }) -} - -pub fn parse_output_product_family_plan( - stage: &str, - operation: OperationRef<'_, '_>, -) -> Result { - let symbol = string_attr(operation, "sym_name")?; - let gamma = optional_symbol_array_attr(operation, "gamma")?; - let evals = symbol_array_attr(operation, "evals")?; - let factors = symbol_array_attr(operation, "factors")?; - let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; - let term_eval_counts = int_array_attr(operation, "term_eval_counts")?; - let term_factor_counts = int_array_attr(operation, "term_factor_counts")?; - verify_count( - "output product family term eval counts", - &symbol, - term_gamma_power_offsets.len(), - term_eval_counts.len(), - )?; - verify_count( - "output product family term factor counts", - &symbol, - term_gamma_power_offsets.len(), - term_factor_counts.len(), - )?; - verify_count( - "output product family evals", - &symbol, - term_eval_counts.iter().sum(), - evals.len(), - )?; - verify_count( - "output product family factors", - &symbol, - term_factor_counts.iter().sum(), - factors.len(), - )?; - let eval_start = gamma.len(); - if let Some(gamma_symbol) = gamma.first() { - let gamma_operand = operand_symbol(operation, 0)?; - if gamma_operand != *gamma_symbol { - return Err(EmitError::new(format!( - "{stage} output product family @{symbol} gamma does not match operand" - ))); - } - } - let eval_end = eval_start + evals.len(); - let eval_operands = operand_symbols(operation, eval_start, eval_end)?; - if evals != eval_operands { - return Err(EmitError::new(format!( - "{stage} output product family @{symbol} evals do not match operands" - ))); - } - let factor_operands = operand_symbols(operation, eval_end, operation.operand_count())?; - if factors != factor_operands { - return Err(EmitError::new(format!( - "{stage} output product family @{symbol} factors do not match operands" - ))); - } - let mut eval_offset = 0; - let mut factor_offset = 0; - let mut terms = Vec::with_capacity(term_gamma_power_offsets.len()); - for ((gamma_power_offset, eval_count), factor_count) in term_gamma_power_offsets - .into_iter() - .zip(term_eval_counts) - .zip(term_factor_counts) - { - if eval_count == 0 && factor_count == 0 { - return Err(EmitError::new(format!( - "{stage} output product family @{symbol} has an empty term" - ))); - } - let eval_end = eval_offset + eval_count; - let factor_end = factor_offset + factor_count; - terms.push(SumcheckOutputProductFamilyTermPlan { - gamma_power_offset, - evals: evals[eval_offset..eval_end].to_vec(), - factors: factors[factor_offset..factor_end].to_vec(), - }); - eval_offset = eval_end; - factor_offset = factor_end; - } - Ok(SumcheckOutputProductFamilyPlan { - symbol, - gamma: gamma.into_iter().next(), - terms, - }) -} - -pub fn parse_output_function_family_plan( - stage: &str, - operation: OperationRef<'_, '_>, -) -> Result { - let symbol = string_attr(operation, "sym_name")?; - let gamma = optional_symbol_array_attr(operation, "gamma")?; - let evals = symbol_array_attr(operation, "evals")?; - let factors = symbol_array_attr(operation, "factors")?; - let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; - let term_functions = string_array_attr(operation, "term_functions")?; - let term_factor_counts = int_array_attr(operation, "term_factor_counts")?; - verify_count( - "output function family term functions", - &symbol, - term_gamma_power_offsets.len(), - term_functions.len(), - )?; - verify_count( - "output function family term factor counts", - &symbol, - term_gamma_power_offsets.len(), - term_factor_counts.len(), - )?; - verify_count( - "output function family evals", - &symbol, - term_gamma_power_offsets.len(), - evals.len(), - )?; - verify_count( - "output function family factors", - &symbol, - term_factor_counts.iter().sum(), - factors.len(), - )?; - let eval_start = gamma.len(); - if let Some(gamma_symbol) = gamma.first() { - let gamma_operand = operand_symbol(operation, 0)?; - if gamma_operand != *gamma_symbol { - return Err(EmitError::new(format!( - "{stage} output function family @{symbol} gamma does not match operand" - ))); - } - } - let eval_end = eval_start + evals.len(); - let eval_operands = operand_symbols(operation, eval_start, eval_end)?; - if evals != eval_operands { - return Err(EmitError::new(format!( - "{stage} output function family @{symbol} evals do not match operands" - ))); - } - let factor_operands = operand_symbols(operation, eval_end, operation.operand_count())?; - if factors != factor_operands { - return Err(EmitError::new(format!( - "{stage} output function family @{symbol} factors do not match operands" - ))); - } - let mut factor_offset = 0; - let mut terms = Vec::with_capacity(term_gamma_power_offsets.len()); - for (((gamma_power_offset, function), eval), factor_count) in term_gamma_power_offsets - .into_iter() - .zip(term_functions) - .zip(evals) - .zip(term_factor_counts) - { - require_output_function(stage, &symbol, &function)?; - let factor_end = factor_offset + factor_count; - terms.push(SumcheckOutputFunctionFamilyTermPlan { - gamma_power_offset, - function, - eval, - factors: factors[factor_offset..factor_end].to_vec(), - }); - factor_offset = factor_end; - } - Ok(SumcheckOutputFunctionFamilyPlan { - symbol, - gamma: gamma.into_iter().next(), - terms, - }) -} - -pub trait FieldExprDependencies { - fn symbol(&self) -> &str; - fn operands(&self) -> &[String]; -} - -pub fn resolve_output_claims( - stage: &str, - output_values: &[StructuredPolynomialEvalPlan], - output_families: &[SumcheckOutputEvalFamilyPlan], - output_product_families: &[SumcheckOutputProductFamilyPlan], - output_function_families: &[SumcheckOutputFunctionFamilyPlan], - field_exprs: &[T], - claim_asts: Vec, -) -> Result, EmitError> -where - T: FieldExprDependencies, -{ - let output_values_by_symbol: BTreeMap<_, _> = output_values - .iter() - .map(|value| (value.symbol.as_str(), value)) - .collect(); - let output_families_by_symbol: BTreeMap<_, _> = output_families - .iter() - .map(|family| (family.symbol.as_str(), family)) - .collect(); - let output_product_families_by_symbol: BTreeMap<_, _> = output_product_families - .iter() - .map(|family| (family.symbol.as_str(), family)) - .collect(); - let output_function_families_by_symbol: BTreeMap<_, _> = output_function_families - .iter() - .map(|family| (family.symbol.as_str(), family)) - .collect(); - let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs - .iter() - .map(|expr| (expr.symbol(), expr)) - .collect(); - claim_asts - .into_iter() - .map(|claim| { - verify_count( - "sumcheck output claim polynomial_evals", - &claim.relation, - claim.polynomial_evals.len(), - claim.polynomial_eval_operands.len(), - )?; - if claim.polynomial_evals != claim.polynomial_eval_operands { - return Err(EmitError::new(format!( - "{stage} output claim for @{} polynomial_evals do not match operands", - claim.relation - ))); - } - let polynomial_evals = claim - .polynomial_evals - .iter() - .map(|symbol| { - output_values_by_symbol - .get(symbol.as_str()) - .copied() - .cloned() - .ok_or_else(|| { - EmitError::new(format!( - "{stage} output claim for @{} references missing output value @{symbol}", - claim.relation - )) - }) - }) - .collect::, EmitError>>()?; - let family_symbols = output_family_dependency_closure( - &output_families_by_symbol, - &output_product_families_by_symbol, - &output_function_families_by_symbol, - &field_exprs_by_symbol, - std::iter::once(claim.claim_value.as_str()), - ); - let eval_families = output_families - .iter() - .filter(|family| family_symbols.eval.contains(&family.symbol)) - .cloned() - .collect(); - let product_families = output_product_families - .iter() - .filter(|family| family_symbols.product.contains(&family.symbol)) - .cloned() - .collect(); - let function_families = output_function_families - .iter() - .filter(|family| family_symbols.function.contains(&family.symbol)) - .cloned() - .collect(); - Ok(SumcheckOutputClaimPlan { - relation: claim.relation, - polynomial_evals, - eval_families, - product_families, - function_families, - claim_value: claim.claim_value, - }) - }) - .collect() -} - -struct OutputFamilyDependencyClosure { - eval: BTreeSet, - product: BTreeSet, - function: BTreeSet, -} - -fn output_family_dependency_closure<'a, T>( - output_families_by_symbol: &BTreeMap<&str, &SumcheckOutputEvalFamilyPlan>, - output_product_families_by_symbol: &BTreeMap<&str, &SumcheckOutputProductFamilyPlan>, - output_function_families_by_symbol: &BTreeMap<&str, &SumcheckOutputFunctionFamilyPlan>, - field_exprs_by_symbol: &BTreeMap<&str, &T>, - roots: impl Iterator, -) -> OutputFamilyDependencyClosure -where - T: FieldExprDependencies, -{ - let mut visited = BTreeSet::new(); - let mut eval_families = BTreeSet::new(); - let mut product_families = BTreeSet::new(); - let mut function_families = BTreeSet::new(); - let mut stack = roots.map(str::to_owned).collect::>(); - while let Some(symbol) = stack.pop() { - if !visited.insert(symbol.clone()) { - continue; - } - if let Some(family) = output_families_by_symbol.get(symbol.as_str()) { - let _inserted = eval_families.insert(family.symbol.clone()); - stack.push(family.gamma.clone()); - stack.extend(family.evals.iter().cloned()); - stack.extend(family.shared_terms.iter().map(|term| term.factor.clone())); - stack.extend( - family - .item_terms - .iter() - .flat_map(|term| term.factors.iter().cloned()), - ); - } - if let Some(family) = output_product_families_by_symbol.get(symbol.as_str()) { - let _inserted = product_families.insert(family.symbol.clone()); - stack.extend(family.gamma.iter().cloned()); - for term in &family.terms { - stack.extend(term.evals.iter().cloned()); - stack.extend(term.factors.iter().cloned()); - } - } - if let Some(family) = output_function_families_by_symbol.get(symbol.as_str()) { - let _inserted = function_families.insert(family.symbol.clone()); - stack.extend(family.gamma.iter().cloned()); - for term in &family.terms { - stack.push(term.eval.clone()); - stack.extend(term.factors.iter().cloned()); - } - } - if let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) { - stack.extend(expr.operands().iter().cloned()); - } - } - OutputFamilyDependencyClosure { - eval: eval_families, - product: product_families, - function: function_families, - } -} - -pub fn prune_output_only_field_exprs<'a, 'b, T>( - field_exprs: &mut Vec, - sumcheck_claim_roots: impl Iterator, - output_claim_roots: impl Iterator, -) where - T: FieldExprDependencies, -{ - let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs - .iter() - .map(|expr| (expr.symbol(), expr)) - .collect(); - let sumcheck_claim_closure = - field_expr_dependency_closure(&field_exprs_by_symbol, sumcheck_claim_roots); - let output_claim_closure = - field_expr_dependency_closure(&field_exprs_by_symbol, output_claim_roots); - field_exprs.retain(|expr| { - !output_claim_closure.contains(expr.symbol()) - || sumcheck_claim_closure.contains(expr.symbol()) - }); -} - -pub struct OutputClaimVerification<'a> { - pub output_values: &'a [StructuredPolynomialEvalPlan], - pub output_families: &'a [SumcheckOutputEvalFamilyPlan], - pub output_product_families: &'a [SumcheckOutputProductFamilyPlan], - pub output_function_families: &'a [SumcheckOutputFunctionFamilyPlan], - pub output_claims: &'a [SumcheckOutputClaimPlan], - pub relations: &'a BTreeSet, - pub field_values: &'a BTreeSet, - pub point_values: &'a BTreeSet, -} - -pub fn verify_output_claims( - stage: &str, - verification: OutputClaimVerification<'_>, -) -> Result<(), EmitError> { - let OutputClaimVerification { - output_values, - output_families, - output_product_families, - output_function_families, - output_claims, - relations, - field_values, - point_values, - } = verification; - for polynomial_eval in output_values { - if !point_values.contains(&polynomial_eval.x_point.source) { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} references missing x-point @{}", - polynomial_eval.symbol, polynomial_eval.x_point.source - ))); - } - if !point_values.contains(&polynomial_eval.y_point.source) { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} references missing y-point @{}", - polynomial_eval.symbol, polynomial_eval.y_point.source - ))); - } - if !matches!( - polynomial_eval.polynomial.as_str(), - "eq" | "eq_plus_one" | "lt" - ) { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported polynomial `{}`", - polynomial_eval.symbol, polynomial_eval.polynomial - ))); - } - verify_structured_polynomial_point_plan(stage, polynomial_eval, &polynomial_eval.x_point)?; - verify_structured_polynomial_point_plan(stage, polynomial_eval, &polynomial_eval.y_point)?; - } - for family in output_families { - if !field_values.contains(&family.gamma) { - return Err(EmitError::new(format!( - "{stage} output eval family @{} references missing gamma @{}", - family.symbol, family.gamma - ))); - } - for eval in &family.evals { - if !field_values.contains(eval) { - return Err(EmitError::new(format!( - "{stage} output eval family @{} references missing eval @{}", - family.symbol, eval - ))); - } - } - for term in &family.shared_terms { - if !field_values.contains(&term.factor) { - return Err(EmitError::new(format!( - "{stage} output eval family @{} references missing shared factor @{}", - family.symbol, term.factor - ))); - } - } - for term in &family.item_terms { - verify_count( - "output eval family item factors", - &family.symbol, - family.evals.len(), - term.factors.len(), - )?; - for factor in &term.factors { - if !field_values.contains(factor) { - return Err(EmitError::new(format!( - "{stage} output eval family @{} references missing item factor @{}", - family.symbol, factor - ))); - } - } - } - } - for family in output_product_families { - if let Some(gamma) = &family.gamma { - if !field_values.contains(gamma) { - return Err(EmitError::new(format!( - "{stage} output product family @{} references missing gamma @{}", - family.symbol, gamma - ))); - } - } - for term in &family.terms { - if term.evals.is_empty() && term.factors.is_empty() { - return Err(EmitError::new(format!( - "{stage} output product family @{} has an empty term", - family.symbol - ))); - } - for eval in &term.evals { - if !field_values.contains(eval) { - return Err(EmitError::new(format!( - "{stage} output product family @{} references missing eval @{}", - family.symbol, eval - ))); - } - } - for factor in &term.factors { - if !field_values.contains(factor) { - return Err(EmitError::new(format!( - "{stage} output product family @{} references missing factor @{}", - family.symbol, factor - ))); - } - } - } - } - for family in output_function_families { - if let Some(gamma) = &family.gamma { - if !field_values.contains(gamma) { - return Err(EmitError::new(format!( - "{stage} output function family @{} references missing gamma @{}", - family.symbol, gamma - ))); - } - } - for term in &family.terms { - require_output_function(stage, &family.symbol, &term.function)?; - if !field_values.contains(&term.eval) { - return Err(EmitError::new(format!( - "{stage} output function family @{} references missing eval @{}", - family.symbol, term.eval - ))); - } - for factor in &term.factors { - if !field_values.contains(factor) { - return Err(EmitError::new(format!( - "{stage} output function family @{} references missing factor @{}", - family.symbol, factor - ))); - } - } - } - } - for claim in output_claims { - if !relations.contains(&claim.relation) { - return Err(EmitError::new(format!( - "{stage} output claim references missing relation @{}", - claim.relation - ))); - } - if !field_values.contains(&claim.claim_value) { - return Err(EmitError::new(format!( - "{stage} output claim for @{} uses missing claim value @{}", - claim.relation, claim.claim_value - ))); - } - } - Ok(()) -} +use crate::ir::Role; +use crate::protocols::jolt::verifier_output_claims::{ + StructuredPolynomialPointPlan, SumcheckOutputClaimPlan, +}; pub fn emit_verifier_output_claim_constants( stage_type: &str, @@ -946,7 +259,6 @@ fn emit_function_family_constants( } fn output_function_kind_expr(function: &str) -> Result<&'static str, EmitError> { - require_output_function("verifier output", "generated constants", function)?; match function { "boolean_zero" => Ok("bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero"), _ => Err(EmitError::new(format!( @@ -955,67 +267,6 @@ fn output_function_kind_expr(function: &str) -> Result<&'static str, EmitError> } } -fn require_output_function(stage: &str, family: &str, function: &str) -> Result<(), EmitError> { - if function == "boolean_zero" { - Ok(()) - } else { - Err(EmitError::new(format!( - "{stage} output function family @{family} has unsupported function `{function}`" - ))) - } -} - -fn field_expr_dependency_closure<'a, T>( - field_exprs_by_symbol: &BTreeMap<&str, &T>, - roots: impl Iterator, -) -> BTreeSet -where - T: FieldExprDependencies, -{ - let mut visited = BTreeSet::new(); - let mut stack = roots.map(str::to_owned).collect::>(); - while let Some(symbol) = stack.pop() { - if !visited.insert(symbol.clone()) { - continue; - } - let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { - continue; - }; - for operand in expr.operands() { - if field_exprs_by_symbol.contains_key(operand.as_str()) { - stack.push(operand.clone()); - } - } - } - visited -} - -fn verify_structured_polynomial_point_plan( - stage: &str, - polynomial_eval: &StructuredPolynomialEvalPlan, - point: &StructuredPolynomialPointPlan, -) -> Result<(), EmitError> { - if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point segment `{}`", - polynomial_eval.symbol, point.segment - ))); - } - if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point length `{}`", - polynomial_eval.symbol, point.length - ))); - } - if !matches!(point.order.as_str(), "as_is" | "reverse") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point order `{}`", - polynomial_eval.symbol, point.order - ))); - } - Ok(()) -} - fn structured_polynomial_kind_expr( stage_type: &str, polynomial: &str, @@ -1102,16 +353,6 @@ fn structured_polynomial_point_order_expr( )) } -fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Result<(), EmitError> { - if expected == actual { - Ok(()) - } else { - Err(EmitError::new(format!( - "{kind} @{symbol} count mismatch: expected {expected}, got {actual}" - ))) - } -} - fn rust_str(value: &str) -> String { format!("{value:?}") } @@ -1138,345 +379,3 @@ fn usize_array(values: &[usize]) -> String { .collect::>() .join(", ") } - -fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(string_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "string")) -} - -fn symbol_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "symbol array"))?; - parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) -} - -fn optional_symbol_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let values = symbol_array_attr(operation, attr)?; - if values.len() <= 1 { - Ok(values) - } else { - Err(EmitError::new(format!( - "{} attr `{attr}` expected zero or one symbols, got {}", - operation_name(operation), - values.len() - ))) - } -} - -fn parse_symbol_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned)) - .collect() -} - -fn string_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "string array"))?; - parse_string_array(&attribute).ok_or_else(|| attr_error(operation, attr, "string array")) -} - -fn parse_string_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| { - item.trim() - .strip_prefix('"')? - .strip_suffix('"') - .map(ToOwned::to_owned) - }) - .collect() -} - -fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .map(parse_integer_attr) - .ok() - .flatten() - .ok_or_else(|| attr_error(operation, attr, "integer")) -} - -fn parse_integer_attr(attribute: Attribute<'_>) -> Option { - attribute - .to_string() - .split_whitespace() - .next() - .and_then(|value| value.parse().ok()) -} - -fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "integer array"))?; - parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) -} - -fn parse_int_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().parse().ok()) - .collect() -} - -fn operand_symbols( - operation: OperationRef<'_, '_>, - start_index: usize, - end_index: usize, -) -> Result, EmitError> { - (start_index..end_index) - .map(|index| operand_symbol(operation, index)) - .collect() -} - -fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result { - let operand = operation.operand(index).map_err(|_| { - EmitError::new(format!( - "{} requires operand {index}", - operation_name(operation) - )) - })?; - let owner = OperationResult::try_from(operand).map_err(|_| { - EmitError::new(format!( - "{} operand {index} must be an op result", - operation_name(operation) - )) - })?; - string_attr(owner.owner(), "sym_name") -} - -fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError { - EmitError::new(format!( - "{} attr `{attr}` is not a {expected}", - operation_name(operation) - )) -} - -#[cfg(test)] -mod tests { - use crate::emit::rust::EmitError; - - use super::{ - resolve_output_claims, FieldExprDependencies, SumcheckOutputClaimAst, - SumcheckOutputEvalFamilyItemTermPlan, SumcheckOutputEvalFamilyPlan, - SumcheckOutputEvalFamilySharedTermPlan, SumcheckOutputFunctionFamilyPlan, - SumcheckOutputFunctionFamilyTermPlan, SumcheckOutputProductFamilyPlan, - SumcheckOutputProductFamilyTermPlan, - }; - - struct TestFieldExpr { - symbol: String, - operands: Vec, - } - - impl FieldExprDependencies for TestFieldExpr { - fn symbol(&self) -> &str { - &self.symbol - } - - fn operands(&self) -> &[String] { - &self.operands - } - } - - #[test] - fn resolves_output_families_reachable_through_field_expressions() -> Result<(), EmitError> { - let inner_family = SumcheckOutputEvalFamilyPlan { - symbol: "inner.family".to_owned(), - gamma: "inner.gamma".to_owned(), - evals: vec!["inner.eval".to_owned()], - power_stride: 1, - value_term_offsets: vec![0], - shared_terms: Vec::new(), - item_terms: Vec::new(), - }; - let outer_family = SumcheckOutputEvalFamilyPlan { - symbol: "outer.family".to_owned(), - gamma: "outer.gamma".to_owned(), - evals: vec!["outer.eval".to_owned()], - power_stride: 1, - value_term_offsets: Vec::new(), - shared_terms: vec![SumcheckOutputEvalFamilySharedTermPlan { - gamma_power_offset: 0, - factor: "outer.shared.factor".to_owned(), - }], - item_terms: vec![SumcheckOutputEvalFamilyItemTermPlan { - gamma_power_offset: 1, - factors: vec!["factor.expr".to_owned()], - }], - }; - let field_exprs = vec![ - TestFieldExpr { - symbol: "claim.expr".to_owned(), - operands: vec!["outer.family".to_owned()], - }, - TestFieldExpr { - symbol: "factor.expr".to_owned(), - operands: vec!["inner.family".to_owned()], - }, - ]; - let claim_asts = vec![SumcheckOutputClaimAst { - relation: "relation".to_owned(), - polynomial_evals: Vec::new(), - polynomial_eval_operands: Vec::new(), - claim_value: "claim.expr".to_owned(), - }]; - - let claims = resolve_output_claims( - "test", - &[], - &[inner_family, outer_family], - &[], - &[], - &field_exprs, - claim_asts, - )?; - let claim = claims - .first() - .ok_or_else(|| EmitError::new("missing resolved output claim"))?; - let family_symbols = claim - .eval_families - .iter() - .map(|family| family.symbol.as_str()) - .collect::>(); - assert_eq!(family_symbols, vec!["inner.family", "outer.family"]); - assert!(claim.product_families.is_empty()); - assert!(claim.function_families.is_empty()); - Ok(()) - } - - #[test] - fn resolves_product_families_reachable_through_field_expressions() -> Result<(), EmitError> { - let product_family = SumcheckOutputProductFamilyPlan { - symbol: "product.family".to_owned(), - gamma: Some("product.gamma".to_owned()), - terms: vec![SumcheckOutputProductFamilyTermPlan { - gamma_power_offset: 2, - evals: vec!["product.eval".to_owned()], - factors: vec!["product.factor.expr".to_owned()], - }], - }; - let field_exprs = vec![ - TestFieldExpr { - symbol: "claim.expr".to_owned(), - operands: vec!["product.family".to_owned()], - }, - TestFieldExpr { - symbol: "product.factor.expr".to_owned(), - operands: vec!["unrelated.scalar".to_owned()], - }, - ]; - let claim_asts = vec![SumcheckOutputClaimAst { - relation: "relation".to_owned(), - polynomial_evals: Vec::new(), - polynomial_eval_operands: Vec::new(), - claim_value: "claim.expr".to_owned(), - }]; - - let claims = resolve_output_claims( - "test", - &[], - &[], - &[product_family], - &[], - &field_exprs, - claim_asts, - )?; - let claim = claims - .first() - .ok_or_else(|| EmitError::new("missing resolved output claim"))?; - assert!(claim.eval_families.is_empty()); - let family_symbols = claim - .product_families - .iter() - .map(|family| family.symbol.as_str()) - .collect::>(); - assert_eq!(family_symbols, vec!["product.family"]); - assert!(claim.function_families.is_empty()); - Ok(()) - } - - #[test] - fn resolves_function_families_reachable_through_field_expressions() -> Result<(), EmitError> { - let function_family = SumcheckOutputFunctionFamilyPlan { - symbol: "function.family".to_owned(), - gamma: Some("function.gamma".to_owned()), - terms: vec![SumcheckOutputFunctionFamilyTermPlan { - gamma_power_offset: 0, - function: "boolean_zero".to_owned(), - eval: "function.eval".to_owned(), - factors: vec!["function.factor.expr".to_owned()], - }], - }; - let field_exprs = vec![ - TestFieldExpr { - symbol: "claim.expr".to_owned(), - operands: vec!["function.family".to_owned()], - }, - TestFieldExpr { - symbol: "function.factor.expr".to_owned(), - operands: vec!["unrelated.scalar".to_owned()], - }, - ]; - let claim_asts = vec![SumcheckOutputClaimAst { - relation: "relation".to_owned(), - polynomial_evals: Vec::new(), - polynomial_eval_operands: Vec::new(), - claim_value: "claim.expr".to_owned(), - }]; - - let claims = resolve_output_claims( - "test", - &[], - &[], - &[], - &[function_family], - &field_exprs, - claim_asts, - )?; - let claim = claims - .first() - .ok_or_else(|| EmitError::new("missing resolved output claim"))?; - assert!(claim.eval_families.is_empty()); - assert!(claim.product_families.is_empty()); - let family_symbols = claim - .function_families - .iter() - .map(|family| family.symbol.as_str()) - .collect::>(); - assert_eq!(family_symbols, vec!["function.family"]); - Ok(()) - } -} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index cbf9c236e1..ad28431a57 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -4,14 +4,15 @@ use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; -use super::output_claims::{ - FieldExprDependencies, StructuredPolynomialEvalPlan as Stage3StructuredPolynomialEvalPlan, +use crate::emit::rust::{push_format, EmitError, RustSourceFile}; +use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::verifier_output_claims::{ + self, FieldExprDependencies, + StructuredPolynomialEvalPlan as Stage3StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage3StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage3SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage3SumcheckOutputClaimPlan, }; -use crate::emit::rust::{push_format, EmitError, RustSourceFile}; -use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::schema::verify_cpu_schema; @@ -549,7 +550,7 @@ impl Stage3CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if role == Role::Prover { - super::output_claims::prune_output_only_field_exprs( + verifier_output_claims::prune_output_only_field_exprs( &mut field_exprs, claims.iter().map(|claim| claim.claim_value.as_str()), output_claim_asts @@ -558,7 +559,7 @@ impl Stage3CpuProgram { ); } let output_claims = if role == Role::Verifier { - super::output_claims::resolve_output_claims( + verifier_output_claims::resolve_output_claims( "stage3", &output_values, &[], @@ -1034,9 +1035,9 @@ impl Stage3CpuProgram { ); let field_values = self.field_value_symbols(); let point_values = self.point_value_symbols(); - super::output_claims::verify_output_claims( + verifier_output_claims::verify_output_claims( "stage3", - super::output_claims::OutputClaimVerification { + verifier_output_claims::OutputClaimVerification { output_values: &self.output_values, output_families: &[], output_product_families: &[], diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 7d3743f003..4a301fbdae 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -9,14 +9,15 @@ use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; -use super::output_claims::{ - FieldExprDependencies, StructuredPolynomialEvalPlan as Stage4StructuredPolynomialEvalPlan, +use crate::emit::rust::{push_format, EmitError, RustSourceFile}; +use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::verifier_output_claims::{ + self, FieldExprDependencies, + StructuredPolynomialEvalPlan as Stage4StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage4StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage4SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage4SumcheckOutputClaimPlan, }; -use crate::emit::rust::{push_format, EmitError, RustSourceFile}; -use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::schema::verify_cpu_schema; @@ -560,7 +561,7 @@ impl Stage4CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if role == Role::Prover { - super::output_claims::prune_output_only_field_exprs( + verifier_output_claims::prune_output_only_field_exprs( &mut field_exprs, claims.iter().map(|claim| claim.claim_value.as_str()), output_claim_asts @@ -569,7 +570,7 @@ impl Stage4CpuProgram { ); } let output_claims = if role == Role::Verifier { - super::output_claims::resolve_output_claims( + verifier_output_claims::resolve_output_claims( "stage4", &output_values, &[], @@ -1065,9 +1066,9 @@ impl Stage4CpuProgram { ); let field_values = self.field_value_symbols(); let point_values = self.point_value_symbols(); - super::output_claims::verify_output_claims( + verifier_output_claims::verify_output_claims( "stage4", - super::output_claims::OutputClaimVerification { + verifier_output_claims::OutputClaimVerification { output_values: &self.output_values, output_families: &[], output_product_families: &[], diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 7bfd4c900a..de89895de2 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -9,14 +9,15 @@ use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; -use super::output_claims::{ - FieldExprDependencies, StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, +use crate::emit::rust::{push_format, EmitError, RustSourceFile}; +use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::verifier_output_claims::{ + self, FieldExprDependencies, + StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage5SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage5SumcheckOutputClaimPlan, }; -use crate::emit::rust::{push_format, EmitError, RustSourceFile}; -use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] @@ -557,7 +558,7 @@ impl Stage5CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; if role == Role::Prover { - super::output_claims::prune_output_only_field_exprs( + verifier_output_claims::prune_output_only_field_exprs( &mut field_exprs, claims.iter().map(|claim| claim.claim_value.as_str()), output_claim_asts @@ -566,7 +567,7 @@ impl Stage5CpuProgram { ); } let output_claims = if role == Role::Verifier { - super::output_claims::resolve_output_claims( + verifier_output_claims::resolve_output_claims( "stage5", &output_values, &[], @@ -901,9 +902,9 @@ impl Stage5CpuProgram { ); let field_values = self.field_value_symbols(); let point_values = self.point_value_symbols(); - super::output_claims::verify_output_claims( + verifier_output_claims::verify_output_claims( "stage5", - super::output_claims::OutputClaimVerification { + verifier_output_claims::OutputClaimVerification { output_values: &self.output_values, output_families: &[], output_product_families: &[], diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 4ffa61bb62..f76ec20c22 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -9,8 +9,11 @@ use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; -use super::output_claims::{ - parse_output_eval_family_plan, parse_output_function_family_plan, +use crate::emit::rust::{push_format, EmitError, RustSourceFile}; +use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::stage6_bytecode_read_raf_plan::emit_stage6_bytecode_read_raf_plan_constants; +use crate::protocols::jolt::verifier_output_claims::{ + self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, @@ -20,9 +23,6 @@ use super::output_claims::{ SumcheckOutputFunctionFamilyPlan as Stage6SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan as Stage6SumcheckOutputProductFamilyPlan, }; -use crate::emit::rust::{push_format, EmitError, RustSourceFile}; -use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::stage6_bytecode_read_raf_plan::emit_stage6_bytecode_read_raf_plan_constants; use crate::schema::verify_cpu_schema; use super::plan_tokens::{ @@ -621,7 +621,7 @@ impl Stage6CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; if role == Role::Prover { - super::output_claims::prune_output_only_field_exprs( + verifier_output_claims::prune_output_only_field_exprs( &mut field_exprs, claims.iter().map(|claim| claim.claim_value.as_str()), output_claim_asts @@ -630,7 +630,7 @@ impl Stage6CpuProgram { ); } let output_claims = if role == Role::Verifier { - super::output_claims::resolve_output_claims( + verifier_output_claims::resolve_output_claims( "stage6", &output_values, &output_families, @@ -977,9 +977,9 @@ impl Stage6CpuProgram { ); let field_values = self.field_value_symbols(); let point_values = self.point_value_symbols(); - super::output_claims::verify_output_claims( + verifier_output_claims::verify_output_claims( "stage6", - super::output_claims::OutputClaimVerification { + verifier_output_claims::OutputClaimVerification { output_values: &self.output_values, output_families: &self.output_families, output_product_families: &self.output_product_families, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 51b68b3a6d..8d2a2e5584 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -9,8 +9,10 @@ use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; -use super::output_claims::{ - parse_output_eval_family_plan, parse_output_function_family_plan, +use crate::emit::rust::{push_format, EmitError, RustSourceFile}; +use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::verifier_output_claims::{ + self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, @@ -20,8 +22,6 @@ use super::output_claims::{ SumcheckOutputFunctionFamilyPlan as Stage7SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan as Stage7SumcheckOutputProductFamilyPlan, }; -use crate::emit::rust::{push_format, EmitError, RustSourceFile}; -use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::schema::verify_cpu_schema; use super::plan_tokens::{ @@ -606,7 +606,7 @@ impl Stage7CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; if role == Role::Prover { - super::output_claims::prune_output_only_field_exprs( + verifier_output_claims::prune_output_only_field_exprs( &mut field_exprs, claims.iter().map(|claim| claim.claim_value.as_str()), output_claim_asts @@ -615,7 +615,7 @@ impl Stage7CpuProgram { ); } let output_claims = if role == Role::Verifier { - super::output_claims::resolve_output_claims( + verifier_output_claims::resolve_output_claims( "stage7", &output_values, &output_families, @@ -962,9 +962,9 @@ impl Stage7CpuProgram { ); let field_values = self.field_value_symbols(); let point_values = self.point_value_symbols(); - super::output_claims::verify_output_claims( + verifier_output_claims::verify_output_claims( "stage7", - super::output_claims::OutputClaimVerification { + verifier_output_claims::OutputClaimVerification { output_values: &self.output_values, output_families: &self.output_families, output_product_families: &self.output_product_families, diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index 497f167940..85c0da4842 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -6,6 +6,7 @@ pub mod phases; pub(crate) mod rust_target_plan; pub(crate) mod stage6_bytecode_read_raf_plan; pub mod validate; +pub(crate) mod verifier_output_claims; pub(crate) mod verifier_plan; pub use artifacts::{ diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs new file mode 100644 index 0000000000..9a88da7317 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -0,0 +1,1105 @@ +use std::collections::{BTreeMap, BTreeSet}; + +use melior::ir::operation::{OperationLike, OperationResult}; +use melior::ir::{Attribute, OperationRef}; + +use crate::emit::rust::EmitError; +use crate::ir::string_attribute_value; +use crate::schema::operation_name; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct StructuredPolynomialPointPlan { + pub source: String, + pub segment: String, + pub length: String, + pub order: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct StructuredPolynomialEvalPlan { + pub symbol: String, + pub polynomial: String, + pub x_point: StructuredPolynomialPointPlan, + pub y_point: StructuredPolynomialPointPlan, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputEvalFamilySharedTermPlan { + pub gamma_power_offset: usize, + pub factor: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputEvalFamilyItemTermPlan { + pub gamma_power_offset: usize, + pub factors: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputEvalFamilyPlan { + pub symbol: String, + pub gamma: String, + pub evals: Vec, + pub power_stride: usize, + pub value_term_offsets: Vec, + pub shared_terms: Vec, + pub item_terms: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputProductFamilyTermPlan { + pub gamma_power_offset: usize, + pub evals: Vec, + pub factors: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputProductFamilyPlan { + pub symbol: String, + pub gamma: Option, + pub terms: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputFunctionFamilyTermPlan { + pub gamma_power_offset: usize, + pub function: String, + pub eval: String, + pub factors: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputFunctionFamilyPlan { + pub symbol: String, + pub gamma: Option, + pub terms: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputClaimPlan { + pub relation: String, + pub polynomial_evals: Vec, + pub eval_families: Vec, + pub product_families: Vec, + pub function_families: Vec, + pub claim_value: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SumcheckOutputClaimAst { + pub relation: String, + pub polynomial_evals: Vec, + pub polynomial_eval_operands: Vec, + pub claim_value: String, +} + +pub fn parse_output_eval_family_plan( + stage: &str, + operation: OperationRef<'_, '_>, +) -> Result { + let symbol = string_attr(operation, "sym_name")?; + let evals = symbol_array_attr(operation, "evals")?; + let shared_factors = symbol_array_attr(operation, "shared_terms")?; + let item_factors = symbol_array_attr(operation, "item_terms")?; + let value_term_offsets = int_array_attr(operation, "value_term_offsets")?; + let shared_term_offsets = int_array_attr(operation, "shared_term_offsets")?; + let item_term_offsets = int_array_attr(operation, "item_term_offsets")?; + verify_count( + "output eval family shared terms", + &symbol, + shared_term_offsets.len(), + shared_factors.len(), + )?; + verify_count( + "output eval family item term factors", + &symbol, + item_term_offsets.len() * evals.len(), + item_factors.len(), + )?; + let gamma = operand_symbol(operation, 0)?; + let eval_operands = operand_symbols(operation, 1, 1 + evals.len())?; + if evals != eval_operands { + return Err(EmitError::new(format!( + "{stage} output eval family @{symbol} evals do not match operands" + ))); + } + let shared_start = 1 + evals.len(); + let shared_end = shared_start + shared_factors.len(); + let shared_operands = operand_symbols(operation, shared_start, shared_end)?; + if shared_factors != shared_operands { + return Err(EmitError::new(format!( + "{stage} output eval family @{symbol} shared_terms do not match operands" + ))); + } + let item_operands = operand_symbols(operation, shared_end, operation.operand_count())?; + if item_factors != item_operands { + return Err(EmitError::new(format!( + "{stage} output eval family @{symbol} item_terms do not match operands" + ))); + } + let shared_terms = shared_term_offsets + .into_iter() + .zip(shared_factors) + .map( + |(gamma_power_offset, factor)| SumcheckOutputEvalFamilySharedTermPlan { + gamma_power_offset, + factor, + }, + ) + .collect(); + let mut item_terms = Vec::with_capacity(item_term_offsets.len()); + for (term_index, gamma_power_offset) in item_term_offsets.into_iter().enumerate() { + let start = term_index * evals.len(); + let end = start + evals.len(); + item_terms.push(SumcheckOutputEvalFamilyItemTermPlan { + gamma_power_offset, + factors: item_factors[start..end].to_vec(), + }); + } + Ok(SumcheckOutputEvalFamilyPlan { + symbol, + gamma, + evals, + power_stride: int_attr(operation, "power_stride")?, + value_term_offsets, + shared_terms, + item_terms, + }) +} + +pub fn parse_output_product_family_plan( + stage: &str, + operation: OperationRef<'_, '_>, +) -> Result { + let symbol = string_attr(operation, "sym_name")?; + let gamma = optional_symbol_array_attr(operation, "gamma")?; + let evals = symbol_array_attr(operation, "evals")?; + let factors = symbol_array_attr(operation, "factors")?; + let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; + let term_eval_counts = int_array_attr(operation, "term_eval_counts")?; + let term_factor_counts = int_array_attr(operation, "term_factor_counts")?; + verify_count( + "output product family term eval counts", + &symbol, + term_gamma_power_offsets.len(), + term_eval_counts.len(), + )?; + verify_count( + "output product family term factor counts", + &symbol, + term_gamma_power_offsets.len(), + term_factor_counts.len(), + )?; + verify_count( + "output product family evals", + &symbol, + term_eval_counts.iter().sum(), + evals.len(), + )?; + verify_count( + "output product family factors", + &symbol, + term_factor_counts.iter().sum(), + factors.len(), + )?; + let eval_start = gamma.len(); + if let Some(gamma_symbol) = gamma.first() { + let gamma_operand = operand_symbol(operation, 0)?; + if gamma_operand != *gamma_symbol { + return Err(EmitError::new(format!( + "{stage} output product family @{symbol} gamma does not match operand" + ))); + } + } + let eval_end = eval_start + evals.len(); + let eval_operands = operand_symbols(operation, eval_start, eval_end)?; + if evals != eval_operands { + return Err(EmitError::new(format!( + "{stage} output product family @{symbol} evals do not match operands" + ))); + } + let factor_operands = operand_symbols(operation, eval_end, operation.operand_count())?; + if factors != factor_operands { + return Err(EmitError::new(format!( + "{stage} output product family @{symbol} factors do not match operands" + ))); + } + let mut eval_offset = 0; + let mut factor_offset = 0; + let mut terms = Vec::with_capacity(term_gamma_power_offsets.len()); + for ((gamma_power_offset, eval_count), factor_count) in term_gamma_power_offsets + .into_iter() + .zip(term_eval_counts) + .zip(term_factor_counts) + { + if eval_count == 0 && factor_count == 0 { + return Err(EmitError::new(format!( + "{stage} output product family @{symbol} has an empty term" + ))); + } + let eval_end = eval_offset + eval_count; + let factor_end = factor_offset + factor_count; + terms.push(SumcheckOutputProductFamilyTermPlan { + gamma_power_offset, + evals: evals[eval_offset..eval_end].to_vec(), + factors: factors[factor_offset..factor_end].to_vec(), + }); + eval_offset = eval_end; + factor_offset = factor_end; + } + Ok(SumcheckOutputProductFamilyPlan { + symbol, + gamma: gamma.into_iter().next(), + terms, + }) +} + +pub fn parse_output_function_family_plan( + stage: &str, + operation: OperationRef<'_, '_>, +) -> Result { + let symbol = string_attr(operation, "sym_name")?; + let gamma = optional_symbol_array_attr(operation, "gamma")?; + let evals = symbol_array_attr(operation, "evals")?; + let factors = symbol_array_attr(operation, "factors")?; + let term_gamma_power_offsets = int_array_attr(operation, "term_gamma_power_offsets")?; + let term_functions = string_array_attr(operation, "term_functions")?; + let term_factor_counts = int_array_attr(operation, "term_factor_counts")?; + verify_count( + "output function family term functions", + &symbol, + term_gamma_power_offsets.len(), + term_functions.len(), + )?; + verify_count( + "output function family term factor counts", + &symbol, + term_gamma_power_offsets.len(), + term_factor_counts.len(), + )?; + verify_count( + "output function family evals", + &symbol, + term_gamma_power_offsets.len(), + evals.len(), + )?; + verify_count( + "output function family factors", + &symbol, + term_factor_counts.iter().sum(), + factors.len(), + )?; + let eval_start = gamma.len(); + if let Some(gamma_symbol) = gamma.first() { + let gamma_operand = operand_symbol(operation, 0)?; + if gamma_operand != *gamma_symbol { + return Err(EmitError::new(format!( + "{stage} output function family @{symbol} gamma does not match operand" + ))); + } + } + let eval_end = eval_start + evals.len(); + let eval_operands = operand_symbols(operation, eval_start, eval_end)?; + if evals != eval_operands { + return Err(EmitError::new(format!( + "{stage} output function family @{symbol} evals do not match operands" + ))); + } + let factor_operands = operand_symbols(operation, eval_end, operation.operand_count())?; + if factors != factor_operands { + return Err(EmitError::new(format!( + "{stage} output function family @{symbol} factors do not match operands" + ))); + } + let mut factor_offset = 0; + let mut terms = Vec::with_capacity(term_gamma_power_offsets.len()); + for (((gamma_power_offset, function), eval), factor_count) in term_gamma_power_offsets + .into_iter() + .zip(term_functions) + .zip(evals) + .zip(term_factor_counts) + { + require_output_function(stage, &symbol, &function)?; + let factor_end = factor_offset + factor_count; + terms.push(SumcheckOutputFunctionFamilyTermPlan { + gamma_power_offset, + function, + eval, + factors: factors[factor_offset..factor_end].to_vec(), + }); + factor_offset = factor_end; + } + Ok(SumcheckOutputFunctionFamilyPlan { + symbol, + gamma: gamma.into_iter().next(), + terms, + }) +} + +pub trait FieldExprDependencies { + fn symbol(&self) -> &str; + fn operands(&self) -> &[String]; +} + +pub fn resolve_output_claims( + stage: &str, + output_values: &[StructuredPolynomialEvalPlan], + output_families: &[SumcheckOutputEvalFamilyPlan], + output_product_families: &[SumcheckOutputProductFamilyPlan], + output_function_families: &[SumcheckOutputFunctionFamilyPlan], + field_exprs: &[T], + claim_asts: Vec, +) -> Result, EmitError> +where + T: FieldExprDependencies, +{ + let output_values_by_symbol: BTreeMap<_, _> = output_values + .iter() + .map(|value| (value.symbol.as_str(), value)) + .collect(); + let output_families_by_symbol: BTreeMap<_, _> = output_families + .iter() + .map(|family| (family.symbol.as_str(), family)) + .collect(); + let output_product_families_by_symbol: BTreeMap<_, _> = output_product_families + .iter() + .map(|family| (family.symbol.as_str(), family)) + .collect(); + let output_function_families_by_symbol: BTreeMap<_, _> = output_function_families + .iter() + .map(|family| (family.symbol.as_str(), family)) + .collect(); + let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs + .iter() + .map(|expr| (expr.symbol(), expr)) + .collect(); + claim_asts + .into_iter() + .map(|claim| { + verify_count( + "sumcheck output claim polynomial_evals", + &claim.relation, + claim.polynomial_evals.len(), + claim.polynomial_eval_operands.len(), + )?; + if claim.polynomial_evals != claim.polynomial_eval_operands { + return Err(EmitError::new(format!( + "{stage} output claim for @{} polynomial_evals do not match operands", + claim.relation + ))); + } + let polynomial_evals = claim + .polynomial_evals + .iter() + .map(|symbol| { + output_values_by_symbol + .get(symbol.as_str()) + .copied() + .cloned() + .ok_or_else(|| { + EmitError::new(format!( + "{stage} output claim for @{} references missing output value @{symbol}", + claim.relation + )) + }) + }) + .collect::, EmitError>>()?; + let family_symbols = output_family_dependency_closure( + &output_families_by_symbol, + &output_product_families_by_symbol, + &output_function_families_by_symbol, + &field_exprs_by_symbol, + std::iter::once(claim.claim_value.as_str()), + ); + let eval_families = output_families + .iter() + .filter(|family| family_symbols.eval.contains(&family.symbol)) + .cloned() + .collect(); + let product_families = output_product_families + .iter() + .filter(|family| family_symbols.product.contains(&family.symbol)) + .cloned() + .collect(); + let function_families = output_function_families + .iter() + .filter(|family| family_symbols.function.contains(&family.symbol)) + .cloned() + .collect(); + Ok(SumcheckOutputClaimPlan { + relation: claim.relation, + polynomial_evals, + eval_families, + product_families, + function_families, + claim_value: claim.claim_value, + }) + }) + .collect() +} + +struct OutputFamilyDependencyClosure { + eval: BTreeSet, + product: BTreeSet, + function: BTreeSet, +} + +fn output_family_dependency_closure<'a, T>( + output_families_by_symbol: &BTreeMap<&str, &SumcheckOutputEvalFamilyPlan>, + output_product_families_by_symbol: &BTreeMap<&str, &SumcheckOutputProductFamilyPlan>, + output_function_families_by_symbol: &BTreeMap<&str, &SumcheckOutputFunctionFamilyPlan>, + field_exprs_by_symbol: &BTreeMap<&str, &T>, + roots: impl Iterator, +) -> OutputFamilyDependencyClosure +where + T: FieldExprDependencies, +{ + let mut visited = BTreeSet::new(); + let mut eval_families = BTreeSet::new(); + let mut product_families = BTreeSet::new(); + let mut function_families = BTreeSet::new(); + let mut stack = roots.map(str::to_owned).collect::>(); + while let Some(symbol) = stack.pop() { + if !visited.insert(symbol.clone()) { + continue; + } + if let Some(family) = output_families_by_symbol.get(symbol.as_str()) { + let _inserted = eval_families.insert(family.symbol.clone()); + stack.push(family.gamma.clone()); + stack.extend(family.evals.iter().cloned()); + stack.extend(family.shared_terms.iter().map(|term| term.factor.clone())); + stack.extend( + family + .item_terms + .iter() + .flat_map(|term| term.factors.iter().cloned()), + ); + } + if let Some(family) = output_product_families_by_symbol.get(symbol.as_str()) { + let _inserted = product_families.insert(family.symbol.clone()); + stack.extend(family.gamma.iter().cloned()); + for term in &family.terms { + stack.extend(term.evals.iter().cloned()); + stack.extend(term.factors.iter().cloned()); + } + } + if let Some(family) = output_function_families_by_symbol.get(symbol.as_str()) { + let _inserted = function_families.insert(family.symbol.clone()); + stack.extend(family.gamma.iter().cloned()); + for term in &family.terms { + stack.push(term.eval.clone()); + stack.extend(term.factors.iter().cloned()); + } + } + if let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) { + stack.extend(expr.operands().iter().cloned()); + } + } + OutputFamilyDependencyClosure { + eval: eval_families, + product: product_families, + function: function_families, + } +} + +pub fn prune_output_only_field_exprs<'a, 'b, T>( + field_exprs: &mut Vec, + sumcheck_claim_roots: impl Iterator, + output_claim_roots: impl Iterator, +) where + T: FieldExprDependencies, +{ + let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs + .iter() + .map(|expr| (expr.symbol(), expr)) + .collect(); + let sumcheck_claim_closure = + field_expr_dependency_closure(&field_exprs_by_symbol, sumcheck_claim_roots); + let output_claim_closure = + field_expr_dependency_closure(&field_exprs_by_symbol, output_claim_roots); + field_exprs.retain(|expr| { + !output_claim_closure.contains(expr.symbol()) + || sumcheck_claim_closure.contains(expr.symbol()) + }); +} + +pub struct OutputClaimVerification<'a> { + pub output_values: &'a [StructuredPolynomialEvalPlan], + pub output_families: &'a [SumcheckOutputEvalFamilyPlan], + pub output_product_families: &'a [SumcheckOutputProductFamilyPlan], + pub output_function_families: &'a [SumcheckOutputFunctionFamilyPlan], + pub output_claims: &'a [SumcheckOutputClaimPlan], + pub relations: &'a BTreeSet, + pub field_values: &'a BTreeSet, + pub point_values: &'a BTreeSet, +} + +pub fn verify_output_claims( + stage: &str, + verification: OutputClaimVerification<'_>, +) -> Result<(), EmitError> { + let OutputClaimVerification { + output_values, + output_families, + output_product_families, + output_function_families, + output_claims, + relations, + field_values, + point_values, + } = verification; + for polynomial_eval in output_values { + if !point_values.contains(&polynomial_eval.x_point.source) { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} references missing x-point @{}", + polynomial_eval.symbol, polynomial_eval.x_point.source + ))); + } + if !point_values.contains(&polynomial_eval.y_point.source) { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} references missing y-point @{}", + polynomial_eval.symbol, polynomial_eval.y_point.source + ))); + } + if !matches!( + polynomial_eval.polynomial.as_str(), + "eq" | "eq_plus_one" | "lt" + ) { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported polynomial `{}`", + polynomial_eval.symbol, polynomial_eval.polynomial + ))); + } + verify_structured_polynomial_point_plan(stage, polynomial_eval, &polynomial_eval.x_point)?; + verify_structured_polynomial_point_plan(stage, polynomial_eval, &polynomial_eval.y_point)?; + } + for family in output_families { + if !field_values.contains(&family.gamma) { + return Err(EmitError::new(format!( + "{stage} output eval family @{} references missing gamma @{}", + family.symbol, family.gamma + ))); + } + for eval in &family.evals { + if !field_values.contains(eval) { + return Err(EmitError::new(format!( + "{stage} output eval family @{} references missing eval @{}", + family.symbol, eval + ))); + } + } + for term in &family.shared_terms { + if !field_values.contains(&term.factor) { + return Err(EmitError::new(format!( + "{stage} output eval family @{} references missing shared factor @{}", + family.symbol, term.factor + ))); + } + } + for term in &family.item_terms { + verify_count( + "output eval family item factors", + &family.symbol, + family.evals.len(), + term.factors.len(), + )?; + for factor in &term.factors { + if !field_values.contains(factor) { + return Err(EmitError::new(format!( + "{stage} output eval family @{} references missing item factor @{}", + family.symbol, factor + ))); + } + } + } + } + for family in output_product_families { + if let Some(gamma) = &family.gamma { + if !field_values.contains(gamma) { + return Err(EmitError::new(format!( + "{stage} output product family @{} references missing gamma @{}", + family.symbol, gamma + ))); + } + } + for term in &family.terms { + if term.evals.is_empty() && term.factors.is_empty() { + return Err(EmitError::new(format!( + "{stage} output product family @{} has an empty term", + family.symbol + ))); + } + for eval in &term.evals { + if !field_values.contains(eval) { + return Err(EmitError::new(format!( + "{stage} output product family @{} references missing eval @{}", + family.symbol, eval + ))); + } + } + for factor in &term.factors { + if !field_values.contains(factor) { + return Err(EmitError::new(format!( + "{stage} output product family @{} references missing factor @{}", + family.symbol, factor + ))); + } + } + } + } + for family in output_function_families { + if let Some(gamma) = &family.gamma { + if !field_values.contains(gamma) { + return Err(EmitError::new(format!( + "{stage} output function family @{} references missing gamma @{}", + family.symbol, gamma + ))); + } + } + for term in &family.terms { + require_output_function(stage, &family.symbol, &term.function)?; + if !field_values.contains(&term.eval) { + return Err(EmitError::new(format!( + "{stage} output function family @{} references missing eval @{}", + family.symbol, term.eval + ))); + } + for factor in &term.factors { + if !field_values.contains(factor) { + return Err(EmitError::new(format!( + "{stage} output function family @{} references missing factor @{}", + family.symbol, factor + ))); + } + } + } + } + for claim in output_claims { + if !relations.contains(&claim.relation) { + return Err(EmitError::new(format!( + "{stage} output claim references missing relation @{}", + claim.relation + ))); + } + if !field_values.contains(&claim.claim_value) { + return Err(EmitError::new(format!( + "{stage} output claim for @{} uses missing claim value @{}", + claim.relation, claim.claim_value + ))); + } + } + Ok(()) +} + +fn require_output_function(stage: &str, family: &str, function: &str) -> Result<(), EmitError> { + if function == "boolean_zero" { + Ok(()) + } else { + Err(EmitError::new(format!( + "{stage} output function family @{family} has unsupported function `{function}`" + ))) + } +} + +fn field_expr_dependency_closure<'a, T>( + field_exprs_by_symbol: &BTreeMap<&str, &T>, + roots: impl Iterator, +) -> BTreeSet +where + T: FieldExprDependencies, +{ + let mut visited = BTreeSet::new(); + let mut stack = roots.map(str::to_owned).collect::>(); + while let Some(symbol) = stack.pop() { + if !visited.insert(symbol.clone()) { + continue; + } + let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { + continue; + }; + for operand in expr.operands() { + if field_exprs_by_symbol.contains_key(operand.as_str()) { + stack.push(operand.clone()); + } + } + } + visited +} + +fn verify_structured_polynomial_point_plan( + stage: &str, + polynomial_eval: &StructuredPolynomialEvalPlan, + point: &StructuredPolynomialPointPlan, +) -> Result<(), EmitError> { + if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point segment `{}`", + polynomial_eval.symbol, point.segment + ))); + } + if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point length `{}`", + polynomial_eval.symbol, point.length + ))); + } + if !matches!(point.order.as_str(), "as_is" | "reverse") { + return Err(EmitError::new(format!( + "{stage} structured polynomial eval @{} has unsupported point order `{}`", + polynomial_eval.symbol, point.order + ))); + } + Ok(()) +} + +fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Result<(), EmitError> { + if expected == actual { + Ok(()) + } else { + Err(EmitError::new(format!( + "{kind} @{symbol} count mismatch: expected {expected}, got {actual}" + ))) + } +} + +fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { + operation + .attribute(attr) + .ok() + .and_then(string_attribute_value) + .ok_or_else(|| attr_error(operation, attr, "string")) +} + +fn symbol_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, EmitError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "symbol array"))?; + parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) +} + +fn optional_symbol_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, EmitError> { + let values = symbol_array_attr(operation, attr)?; + if values.len() <= 1 { + Ok(values) + } else { + Err(EmitError::new(format!( + "{} attr `{attr}` expected zero or one symbols, got {}", + operation_name(operation), + values.len() + ))) + } +} + +fn parse_symbol_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned)) + .collect() +} + +fn string_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, EmitError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "string array"))?; + parse_string_array(&attribute).ok_or_else(|| attr_error(operation, attr, "string array")) +} + +fn parse_string_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| { + item.trim() + .strip_prefix('"')? + .strip_suffix('"') + .map(ToOwned::to_owned) + }) + .collect() +} + +fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { + operation + .attribute(attr) + .map(parse_integer_attr) + .ok() + .flatten() + .ok_or_else(|| attr_error(operation, attr, "integer")) +} + +fn parse_integer_attr(attribute: Attribute<'_>) -> Option { + attribute + .to_string() + .split_whitespace() + .next() + .and_then(|value| value.parse().ok()) +} + +fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, EmitError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "integer array"))?; + parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) +} + +fn parse_int_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| item.trim().parse().ok()) + .collect() +} + +fn operand_symbols( + operation: OperationRef<'_, '_>, + start_index: usize, + end_index: usize, +) -> Result, EmitError> { + (start_index..end_index) + .map(|index| operand_symbol(operation, index)) + .collect() +} + +fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result { + let operand = operation.operand(index).map_err(|_| { + EmitError::new(format!( + "{} requires operand {index}", + operation_name(operation) + )) + })?; + let owner = OperationResult::try_from(operand).map_err(|_| { + EmitError::new(format!( + "{} operand {index} must be an op result", + operation_name(operation) + )) + })?; + string_attr(owner.owner(), "sym_name") +} + +fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError { + EmitError::new(format!( + "{} attr `{attr}` is not a {expected}", + operation_name(operation) + )) +} + +#[cfg(test)] +mod tests { + use crate::emit::rust::EmitError; + + use super::{ + resolve_output_claims, FieldExprDependencies, SumcheckOutputClaimAst, + SumcheckOutputEvalFamilyItemTermPlan, SumcheckOutputEvalFamilyPlan, + SumcheckOutputEvalFamilySharedTermPlan, SumcheckOutputFunctionFamilyPlan, + SumcheckOutputFunctionFamilyTermPlan, SumcheckOutputProductFamilyPlan, + SumcheckOutputProductFamilyTermPlan, + }; + + struct TestFieldExpr { + symbol: String, + operands: Vec, + } + + impl FieldExprDependencies for TestFieldExpr { + fn symbol(&self) -> &str { + &self.symbol + } + + fn operands(&self) -> &[String] { + &self.operands + } + } + + #[test] + fn resolves_output_families_reachable_through_field_expressions() -> Result<(), EmitError> { + let inner_family = SumcheckOutputEvalFamilyPlan { + symbol: "inner.family".to_owned(), + gamma: "inner.gamma".to_owned(), + evals: vec!["inner.eval".to_owned()], + power_stride: 1, + value_term_offsets: vec![0], + shared_terms: Vec::new(), + item_terms: Vec::new(), + }; + let outer_family = SumcheckOutputEvalFamilyPlan { + symbol: "outer.family".to_owned(), + gamma: "outer.gamma".to_owned(), + evals: vec!["outer.eval".to_owned()], + power_stride: 1, + value_term_offsets: Vec::new(), + shared_terms: vec![SumcheckOutputEvalFamilySharedTermPlan { + gamma_power_offset: 0, + factor: "outer.shared.factor".to_owned(), + }], + item_terms: vec![SumcheckOutputEvalFamilyItemTermPlan { + gamma_power_offset: 1, + factors: vec!["factor.expr".to_owned()], + }], + }; + let field_exprs = vec![ + TestFieldExpr { + symbol: "claim.expr".to_owned(), + operands: vec!["outer.family".to_owned()], + }, + TestFieldExpr { + symbol: "factor.expr".to_owned(), + operands: vec!["inner.family".to_owned()], + }, + ]; + let claim_asts = vec![SumcheckOutputClaimAst { + relation: "relation".to_owned(), + polynomial_evals: Vec::new(), + polynomial_eval_operands: Vec::new(), + claim_value: "claim.expr".to_owned(), + }]; + + let claims = resolve_output_claims( + "test", + &[], + &[inner_family, outer_family], + &[], + &[], + &field_exprs, + claim_asts, + )?; + let claim = claims + .first() + .ok_or_else(|| EmitError::new("missing resolved output claim"))?; + let family_symbols = claim + .eval_families + .iter() + .map(|family| family.symbol.as_str()) + .collect::>(); + assert_eq!(family_symbols, vec!["inner.family", "outer.family"]); + assert!(claim.product_families.is_empty()); + assert!(claim.function_families.is_empty()); + Ok(()) + } + + #[test] + fn resolves_product_families_reachable_through_field_expressions() -> Result<(), EmitError> { + let product_family = SumcheckOutputProductFamilyPlan { + symbol: "product.family".to_owned(), + gamma: Some("product.gamma".to_owned()), + terms: vec![SumcheckOutputProductFamilyTermPlan { + gamma_power_offset: 2, + evals: vec!["product.eval".to_owned()], + factors: vec!["product.factor.expr".to_owned()], + }], + }; + let field_exprs = vec![ + TestFieldExpr { + symbol: "claim.expr".to_owned(), + operands: vec!["product.family".to_owned()], + }, + TestFieldExpr { + symbol: "product.factor.expr".to_owned(), + operands: vec!["unrelated.scalar".to_owned()], + }, + ]; + let claim_asts = vec![SumcheckOutputClaimAst { + relation: "relation".to_owned(), + polynomial_evals: Vec::new(), + polynomial_eval_operands: Vec::new(), + claim_value: "claim.expr".to_owned(), + }]; + + let claims = resolve_output_claims( + "test", + &[], + &[], + &[product_family], + &[], + &field_exprs, + claim_asts, + )?; + let claim = claims + .first() + .ok_or_else(|| EmitError::new("missing resolved output claim"))?; + assert!(claim.eval_families.is_empty()); + let family_symbols = claim + .product_families + .iter() + .map(|family| family.symbol.as_str()) + .collect::>(); + assert_eq!(family_symbols, vec!["product.family"]); + assert!(claim.function_families.is_empty()); + Ok(()) + } + + #[test] + fn resolves_function_families_reachable_through_field_expressions() -> Result<(), EmitError> { + let function_family = SumcheckOutputFunctionFamilyPlan { + symbol: "function.family".to_owned(), + gamma: Some("function.gamma".to_owned()), + terms: vec![SumcheckOutputFunctionFamilyTermPlan { + gamma_power_offset: 0, + function: "boolean_zero".to_owned(), + eval: "function.eval".to_owned(), + factors: vec!["function.factor.expr".to_owned()], + }], + }; + let field_exprs = vec![ + TestFieldExpr { + symbol: "claim.expr".to_owned(), + operands: vec!["function.family".to_owned()], + }, + TestFieldExpr { + symbol: "function.factor.expr".to_owned(), + operands: vec!["unrelated.scalar".to_owned()], + }, + ]; + let claim_asts = vec![SumcheckOutputClaimAst { + relation: "relation".to_owned(), + polynomial_evals: Vec::new(), + polynomial_eval_operands: Vec::new(), + claim_value: "claim.expr".to_owned(), + }]; + + let claims = resolve_output_claims( + "test", + &[], + &[], + &[], + &[function_family], + &field_exprs, + claim_asts, + )?; + let claim = claims + .first() + .ok_or_else(|| EmitError::new("missing resolved output claim"))?; + assert!(claim.eval_families.is_empty()); + assert!(claim.product_families.is_empty()); + let family_symbols = claim + .function_families + .iter() + .map(|family| family.symbol.as_str()) + .collect::>(); + assert_eq!(family_symbols, vec!["function.family"]); + Ok(()) + } +} From 214555e3aa92c735444353a2e23f81196690feb3 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 01:14:34 -0600 Subject: [PATCH 063/171] refactor(bolt): type output claim tags --- .../protocols/jolt/emit/rust/output_claims.rs | 105 ++++----- .../src/protocols/jolt/emit/rust/stage3.rs | 35 +-- .../src/protocols/jolt/emit/rust/stage4.rs | 35 +-- .../src/protocols/jolt/emit/rust/stage5.rs | 35 +-- .../src/protocols/jolt/emit/rust/stage6.rs | 35 +-- .../src/protocols/jolt/emit/rust/stage7.rs | 35 +-- .../protocols/jolt/verifier_output_claims.rs | 201 +++++++++++++----- 7 files changed, 278 insertions(+), 203 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index b1df6ea39b..064df5c933 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -1,7 +1,9 @@ use crate::emit::rust::{push_format, EmitError}; use crate::ir::Role; use crate::protocols::jolt::verifier_output_claims::{ - StructuredPolynomialPointPlan, SumcheckOutputClaimPlan, + StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, SumcheckOutputClaimPlan, + SumcheckOutputFunctionKind, }; pub fn emit_verifier_output_claim_constants( @@ -23,9 +25,9 @@ pub fn emit_verifier_output_claim_constants( Ok(format!( " {stage_type}StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", rust_str(&value.symbol), - structured_polynomial_kind_expr(stage_type, &value.polynomial)?, - structured_polynomial_point_expr(stage_type, &value.x_point)?, - structured_polynomial_point_expr(stage_type, &value.y_point)?, + structured_polynomial_kind_expr(stage_type, value.polynomial), + structured_polynomial_point_expr(stage_type, &value.x_point), + structured_polynomial_point_expr(stage_type, &value.y_point), )) }) .collect::, EmitError>>()? @@ -228,7 +230,7 @@ fn emit_function_family_constants( term_rows.push(format!( " bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan {{ gamma_power_offset: {}, function: {}, eval: {}, factors: {factors_name} }},", term.gamma_power_offset, - output_function_kind_expr(&term.function)?, + output_function_kind_expr(term.function), rust_str(&term.eval) )); } @@ -258,99 +260,72 @@ fn emit_function_family_constants( Ok(families_name) } -fn output_function_kind_expr(function: &str) -> Result<&'static str, EmitError> { +fn output_function_kind_expr(function: SumcheckOutputFunctionKind) -> &'static str { match function { - "boolean_zero" => Ok("bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero"), - _ => Err(EmitError::new(format!( - "unsupported output function `{function}`" - ))), + SumcheckOutputFunctionKind::BooleanZero => { + "bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero" + } } } fn structured_polynomial_kind_expr( stage_type: &str, - polynomial: &str, -) -> Result { + polynomial: StructuredPolynomialKind, +) -> String { let variant = match polynomial { - "eq" => "Eq", - "eq_plus_one" => "EqPlusOne", - "lt" => "Lt", - _ => { - return Err(EmitError::new(format!( - "unsupported {stage_type} structured polynomial `{polynomial}`" - ))) - } + StructuredPolynomialKind::Eq => "Eq", + StructuredPolynomialKind::EqPlusOne => "EqPlusOne", + StructuredPolynomialKind::Lt => "Lt", }; - Ok(format!("{stage_type}StructuredPolynomialKind::{variant}")) + format!("{stage_type}StructuredPolynomialKind::{variant}") } fn structured_polynomial_point_expr( stage_type: &str, point: &StructuredPolynomialPointPlan, -) -> Result { - Ok(format!( +) -> String { + format!( "{stage_type}StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", rust_str(&point.source), - structured_polynomial_point_segment_expr(stage_type, &point.segment)?, - structured_polynomial_point_length_expr(stage_type, &point.length)?, - structured_polynomial_point_order_expr(stage_type, &point.order)?, - )) + structured_polynomial_point_segment_expr(stage_type, point.segment), + structured_polynomial_point_length_expr(stage_type, point.length), + structured_polynomial_point_order_expr(stage_type, point.order), + ) } fn structured_polynomial_point_segment_expr( stage_type: &str, - segment: &str, -) -> Result { + segment: StructuredPolynomialPointSegment, +) -> String { let variant = match segment { - "full" => "Full", - "prefix" => "Prefix", - "suffix" => "Suffix", - _ => { - return Err(EmitError::new(format!( - "unsupported {stage_type} output point segment `{segment}`" - ))) - } + StructuredPolynomialPointSegment::Full => "Full", + StructuredPolynomialPointSegment::Prefix => "Prefix", + StructuredPolynomialPointSegment::Suffix => "Suffix", }; - Ok(format!( - "{stage_type}StructuredPolynomialPointSegment::{variant}" - )) + format!("{stage_type}StructuredPolynomialPointSegment::{variant}") } fn structured_polynomial_point_length_expr( stage_type: &str, - length: &str, -) -> Result { + length: StructuredPolynomialPointLength, +) -> String { let variant = match length { - "full" => "Full", - "x_point" => "XPoint", - "y_point" => "YPoint", - _ => { - return Err(EmitError::new(format!( - "unsupported {stage_type} structured polynomial point length `{length}`" - ))) - } + StructuredPolynomialPointLength::Full => "Full", + StructuredPolynomialPointLength::XPoint => "XPoint", + StructuredPolynomialPointLength::YPoint => "YPoint", }; - Ok(format!( - "{stage_type}StructuredPolynomialPointLength::{variant}" - )) + format!("{stage_type}StructuredPolynomialPointLength::{variant}") } fn structured_polynomial_point_order_expr( stage_type: &str, - order: &str, -) -> Result { + order: StructuredPolynomialPointOrder, +) -> String { let variant = match order { - "as_is" => "AsIs", - "reverse" => "Reverse", - _ => { - return Err(EmitError::new(format!( - "unsupported {stage_type} output point order `{order}`" - ))) - } + StructuredPolynomialPointOrder::AsIs => "AsIs", + StructuredPolynomialPointOrder::Reverse => "Reverse", }; - Ok(format!( - "{stage_type}StructuredPolynomialPointOrder::{variant}" - )) + format!("{stage_type}StructuredPolynomialPointOrder::{variant}") } fn rust_str(value: &str) -> String { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index ad28431a57..4588491bf2 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -469,22 +469,25 @@ impl Stage3CpuProgram { }); } "cpu.structured_polynomial_eval" => { - output_values.push(Stage3StructuredPolynomialEvalPlan { - symbol: string_attr(op, "sym_name")?, - polynomial: string_attr(op, "polynomial")?, - x_point: Stage3StructuredPolynomialPointPlan { - source: operand_symbol(op, 0)?, - segment: string_attr(op, "x_point_segment")?, - length: string_attr(op, "x_point_length")?, - order: string_attr(op, "x_point_order")?, - }, - y_point: Stage3StructuredPolynomialPointPlan { - source: operand_symbol(op, 1)?, - segment: string_attr(op, "y_point_segment")?, - length: string_attr(op, "y_point_length")?, - order: string_attr(op, "y_point_order")?, - }, - }); + let symbol = string_attr(op, "sym_name")?; + let x_point = Stage3StructuredPolynomialPointPlan::from_cpu( + operand_symbol(op, 0)?, + string_attr(op, "x_point_segment")?, + string_attr(op, "x_point_length")?, + string_attr(op, "x_point_order")?, + )?; + let y_point = Stage3StructuredPolynomialPointPlan::from_cpu( + operand_symbol(op, 1)?, + string_attr(op, "y_point_segment")?, + string_attr(op, "y_point_length")?, + string_attr(op, "y_point_order")?, + )?; + output_values.push(Stage3StructuredPolynomialEvalPlan::from_cpu( + symbol, + string_attr(op, "polynomial")?, + x_point, + y_point, + )?); } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage3SumcheckOutputClaimAst { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 4a301fbdae..8f2af01ef9 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -480,22 +480,25 @@ impl Stage4CpuProgram { }); } "cpu.structured_polynomial_eval" => { - output_values.push(Stage4StructuredPolynomialEvalPlan { - symbol: string_attr(op, "sym_name")?, - polynomial: string_attr(op, "polynomial")?, - x_point: Stage4StructuredPolynomialPointPlan { - source: operand_symbol(op, 0)?, - segment: string_attr(op, "x_point_segment")?, - length: string_attr(op, "x_point_length")?, - order: string_attr(op, "x_point_order")?, - }, - y_point: Stage4StructuredPolynomialPointPlan { - source: operand_symbol(op, 1)?, - segment: string_attr(op, "y_point_segment")?, - length: string_attr(op, "y_point_length")?, - order: string_attr(op, "y_point_order")?, - }, - }); + let symbol = string_attr(op, "sym_name")?; + let x_point = Stage4StructuredPolynomialPointPlan::from_cpu( + operand_symbol(op, 0)?, + string_attr(op, "x_point_segment")?, + string_attr(op, "x_point_length")?, + string_attr(op, "x_point_order")?, + )?; + let y_point = Stage4StructuredPolynomialPointPlan::from_cpu( + operand_symbol(op, 1)?, + string_attr(op, "y_point_segment")?, + string_attr(op, "y_point_length")?, + string_attr(op, "y_point_order")?, + )?; + output_values.push(Stage4StructuredPolynomialEvalPlan::from_cpu( + symbol, + string_attr(op, "polynomial")?, + x_point, + y_point, + )?); } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage4SumcheckOutputClaimAst { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index de89895de2..ec11c47b6d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -478,22 +478,25 @@ impl Stage5CpuProgram { }); } "cpu.structured_polynomial_eval" => { - output_values.push(Stage5StructuredPolynomialEvalPlan { - symbol: string_attr(op, "sym_name")?, - polynomial: string_attr(op, "polynomial")?, - x_point: Stage5StructuredPolynomialPointPlan { - source: operand_symbol(op, 0)?, - segment: string_attr(op, "x_point_segment")?, - length: string_attr(op, "x_point_length")?, - order: string_attr(op, "x_point_order")?, - }, - y_point: Stage5StructuredPolynomialPointPlan { - source: operand_symbol(op, 1)?, - segment: string_attr(op, "y_point_segment")?, - length: string_attr(op, "y_point_length")?, - order: string_attr(op, "y_point_order")?, - }, - }); + let symbol = string_attr(op, "sym_name")?; + let x_point = Stage5StructuredPolynomialPointPlan::from_cpu( + operand_symbol(op, 0)?, + string_attr(op, "x_point_segment")?, + string_attr(op, "x_point_length")?, + string_attr(op, "x_point_order")?, + )?; + let y_point = Stage5StructuredPolynomialPointPlan::from_cpu( + operand_symbol(op, 1)?, + string_attr(op, "y_point_segment")?, + string_attr(op, "y_point_length")?, + string_attr(op, "y_point_order")?, + )?; + output_values.push(Stage5StructuredPolynomialEvalPlan::from_cpu( + symbol, + string_attr(op, "polynomial")?, + x_point, + y_point, + )?); } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage5SumcheckOutputClaimAst { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index f76ec20c22..b252183de5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -525,22 +525,25 @@ impl Stage6CpuProgram { }); } "cpu.structured_polynomial_eval" => { - output_values.push(Stage6StructuredPolynomialEvalPlan { - symbol: string_attr(op, "sym_name")?, - polynomial: string_attr(op, "polynomial")?, - x_point: Stage6StructuredPolynomialPointPlan { - source: operand_symbol(op, 0)?, - segment: string_attr(op, "x_point_segment")?, - length: string_attr(op, "x_point_length")?, - order: string_attr(op, "x_point_order")?, - }, - y_point: Stage6StructuredPolynomialPointPlan { - source: operand_symbol(op, 1)?, - segment: string_attr(op, "y_point_segment")?, - length: string_attr(op, "y_point_length")?, - order: string_attr(op, "y_point_order")?, - }, - }); + let symbol = string_attr(op, "sym_name")?; + let x_point = Stage6StructuredPolynomialPointPlan::from_cpu( + operand_symbol(op, 0)?, + string_attr(op, "x_point_segment")?, + string_attr(op, "x_point_length")?, + string_attr(op, "x_point_order")?, + )?; + let y_point = Stage6StructuredPolynomialPointPlan::from_cpu( + operand_symbol(op, 1)?, + string_attr(op, "y_point_segment")?, + string_attr(op, "y_point_length")?, + string_attr(op, "y_point_order")?, + )?; + output_values.push(Stage6StructuredPolynomialEvalPlan::from_cpu( + symbol, + string_attr(op, "polynomial")?, + x_point, + y_point, + )?); } "cpu.sumcheck_output_eval_family" => { output_families.push(parse_output_eval_family_plan("stage6", op)?); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 8d2a2e5584..b221179e9c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -510,22 +510,25 @@ impl Stage7CpuProgram { }); } "cpu.structured_polynomial_eval" => { - output_values.push(Stage7StructuredPolynomialEvalPlan { - symbol: string_attr(op, "sym_name")?, - polynomial: string_attr(op, "polynomial")?, - x_point: Stage7StructuredPolynomialPointPlan { - source: operand_symbol(op, 0)?, - segment: string_attr(op, "x_point_segment")?, - length: string_attr(op, "x_point_length")?, - order: string_attr(op, "x_point_order")?, - }, - y_point: Stage7StructuredPolynomialPointPlan { - source: operand_symbol(op, 1)?, - segment: string_attr(op, "y_point_segment")?, - length: string_attr(op, "y_point_length")?, - order: string_attr(op, "y_point_order")?, - }, - }); + let symbol = string_attr(op, "sym_name")?; + let x_point = Stage7StructuredPolynomialPointPlan::from_cpu( + operand_symbol(op, 0)?, + string_attr(op, "x_point_segment")?, + string_attr(op, "x_point_length")?, + string_attr(op, "x_point_order")?, + )?; + let y_point = Stage7StructuredPolynomialPointPlan::from_cpu( + operand_symbol(op, 1)?, + string_attr(op, "y_point_segment")?, + string_attr(op, "y_point_length")?, + string_attr(op, "y_point_order")?, + )?; + output_values.push(Stage7StructuredPolynomialEvalPlan::from_cpu( + symbol, + string_attr(op, "polynomial")?, + x_point, + y_point, + )?); } "cpu.sumcheck_output_eval_family" => { output_families.push(parse_output_eval_family_plan("stage7", op)?); diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index 9a88da7317..c0278b5350 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -7,22 +7,154 @@ use crate::emit::rust::EmitError; use crate::ir::string_attribute_value; use crate::schema::operation_name; +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum StructuredPolynomialKind { + Eq, + EqPlusOne, + Lt, +} + +impl StructuredPolynomialKind { + pub fn from_cpu_attr(value: &str) -> Result { + match value { + "eq" => Ok(Self::Eq), + "eq_plus_one" => Ok(Self::EqPlusOne), + "lt" => Ok(Self::Lt), + _ => Err(EmitError::new(format!( + "unsupported structured polynomial `{value}`" + ))), + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum StructuredPolynomialPointSegment { + Full, + Prefix, + Suffix, +} + +impl StructuredPolynomialPointSegment { + pub fn from_cpu_attr(value: &str) -> Result { + match value { + "full" => Ok(Self::Full), + "prefix" => Ok(Self::Prefix), + "suffix" => Ok(Self::Suffix), + _ => Err(EmitError::new(format!( + "unsupported structured polynomial point segment `{value}`" + ))), + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum StructuredPolynomialPointLength { + Full, + XPoint, + YPoint, +} + +impl StructuredPolynomialPointLength { + pub fn from_cpu_attr(value: &str) -> Result { + match value { + "full" => Ok(Self::Full), + "x_point" => Ok(Self::XPoint), + "y_point" => Ok(Self::YPoint), + _ => Err(EmitError::new(format!( + "unsupported structured polynomial point length `{value}`" + ))), + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum StructuredPolynomialPointOrder { + AsIs, + Reverse, +} + +impl StructuredPolynomialPointOrder { + pub fn from_cpu_attr(value: &str) -> Result { + match value { + "as_is" => Ok(Self::AsIs), + "reverse" => Ok(Self::Reverse), + _ => Err(EmitError::new(format!( + "unsupported structured polynomial point order `{value}`" + ))), + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SumcheckOutputFunctionKind { + BooleanZero, +} + +impl SumcheckOutputFunctionKind { + pub fn from_cpu_attr(value: &str) -> Result { + match value { + "boolean_zero" => Ok(Self::BooleanZero), + _ => Err(EmitError::new(format!( + "unsupported output function `{value}`" + ))), + } + } +} + +impl PartialEq<&str> for SumcheckOutputFunctionKind { + fn eq(&self, other: &&str) -> bool { + matches!((self, *other), (Self::BooleanZero, "boolean_zero")) + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct StructuredPolynomialPointPlan { pub source: String, - pub segment: String, - pub length: String, - pub order: String, + pub segment: StructuredPolynomialPointSegment, + pub length: StructuredPolynomialPointLength, + pub order: StructuredPolynomialPointOrder, +} + +impl StructuredPolynomialPointPlan { + pub fn from_cpu( + source: String, + segment: String, + length: String, + order: String, + ) -> Result { + Ok(Self { + source, + segment: StructuredPolynomialPointSegment::from_cpu_attr(&segment)?, + length: StructuredPolynomialPointLength::from_cpu_attr(&length)?, + order: StructuredPolynomialPointOrder::from_cpu_attr(&order)?, + }) + } } #[derive(Clone, Debug, PartialEq, Eq)] pub struct StructuredPolynomialEvalPlan { pub symbol: String, - pub polynomial: String, + pub polynomial: StructuredPolynomialKind, pub x_point: StructuredPolynomialPointPlan, pub y_point: StructuredPolynomialPointPlan, } +impl StructuredPolynomialEvalPlan { + pub fn from_cpu( + symbol: String, + polynomial: String, + x_point: StructuredPolynomialPointPlan, + y_point: StructuredPolynomialPointPlan, + ) -> Result { + Ok(Self { + symbol, + polynomial: StructuredPolynomialKind::from_cpu_attr(&polynomial)?, + x_point, + y_point, + }) + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct SumcheckOutputEvalFamilySharedTermPlan { pub gamma_power_offset: usize, @@ -63,7 +195,7 @@ pub struct SumcheckOutputProductFamilyPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct SumcheckOutputFunctionFamilyTermPlan { pub gamma_power_offset: usize, - pub function: String, + pub function: SumcheckOutputFunctionKind, pub eval: String, pub factors: Vec, } @@ -319,11 +451,12 @@ pub fn parse_output_function_family_plan( .zip(evals) .zip(term_factor_counts) { - require_output_function(stage, &symbol, &function)?; let factor_end = factor_offset + factor_count; terms.push(SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset, - function, + function: SumcheckOutputFunctionKind::from_cpu_attr(&function).map_err(|error| { + EmitError::new(format!("{stage} output function family @{symbol}: {error}")) + })?, eval, factors: factors[factor_offset..factor_end].to_vec(), }); @@ -561,17 +694,6 @@ pub fn verify_output_claims( polynomial_eval.symbol, polynomial_eval.y_point.source ))); } - if !matches!( - polynomial_eval.polynomial.as_str(), - "eq" | "eq_plus_one" | "lt" - ) { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported polynomial `{}`", - polynomial_eval.symbol, polynomial_eval.polynomial - ))); - } - verify_structured_polynomial_point_plan(stage, polynomial_eval, &polynomial_eval.x_point)?; - verify_structured_polynomial_point_plan(stage, polynomial_eval, &polynomial_eval.y_point)?; } for family in output_families { if !field_values.contains(&family.gamma) { @@ -657,7 +779,6 @@ pub fn verify_output_claims( } } for term in &family.terms { - require_output_function(stage, &family.symbol, &term.function)?; if !field_values.contains(&term.eval) { return Err(EmitError::new(format!( "{stage} output function family @{} references missing eval @{}", @@ -691,16 +812,6 @@ pub fn verify_output_claims( Ok(()) } -fn require_output_function(stage: &str, family: &str, function: &str) -> Result<(), EmitError> { - if function == "boolean_zero" { - Ok(()) - } else { - Err(EmitError::new(format!( - "{stage} output function family @{family} has unsupported function `{function}`" - ))) - } -} - fn field_expr_dependency_closure<'a, T>( field_exprs_by_symbol: &BTreeMap<&str, &T>, roots: impl Iterator, @@ -726,32 +837,6 @@ where visited } -fn verify_structured_polynomial_point_plan( - stage: &str, - polynomial_eval: &StructuredPolynomialEvalPlan, - point: &StructuredPolynomialPointPlan, -) -> Result<(), EmitError> { - if !matches!(point.segment.as_str(), "full" | "prefix" | "suffix") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point segment `{}`", - polynomial_eval.symbol, point.segment - ))); - } - if !matches!(point.length.as_str(), "full" | "x_point" | "y_point") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point length `{}`", - polynomial_eval.symbol, point.length - ))); - } - if !matches!(point.order.as_str(), "as_is" | "reverse") { - return Err(EmitError::new(format!( - "{stage} structured polynomial eval @{} has unsupported point order `{}`", - polynomial_eval.symbol, point.order - ))); - } - Ok(()) -} - fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Result<(), EmitError> { if expected == actual { Ok(()) @@ -915,8 +1000,8 @@ mod tests { resolve_output_claims, FieldExprDependencies, SumcheckOutputClaimAst, SumcheckOutputEvalFamilyItemTermPlan, SumcheckOutputEvalFamilyPlan, SumcheckOutputEvalFamilySharedTermPlan, SumcheckOutputFunctionFamilyPlan, - SumcheckOutputFunctionFamilyTermPlan, SumcheckOutputProductFamilyPlan, - SumcheckOutputProductFamilyTermPlan, + SumcheckOutputFunctionFamilyTermPlan, SumcheckOutputFunctionKind, + SumcheckOutputProductFamilyPlan, SumcheckOutputProductFamilyTermPlan, }; struct TestFieldExpr { @@ -1058,7 +1143,7 @@ mod tests { gamma: Some("function.gamma".to_owned()), terms: vec![SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, - function: "boolean_zero".to_owned(), + function: SumcheckOutputFunctionKind::BooleanZero, eval: "function.eval".to_owned(), factors: vec!["function.factor.expr".to_owned()], }], From 493abb48519b3f6809229e879961fb458e0e9aef Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 01:18:34 -0600 Subject: [PATCH 064/171] refactor(bolt): plan stage5 read raf eval families --- .../src/protocols/jolt/emit/rust/stage5.rs | 171 ++++++++++++------ 1 file changed, 115 insertions(+), 56 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index ec11c47b6d..6d4423fcff 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -23,6 +23,7 @@ use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5CpuProgram { pub role: Role, + pub(crate) instruction_read_raf_plan: Option, pub params: Stage5Params, pub steps: Vec, pub transcript_squeezes: Vec, @@ -186,6 +187,85 @@ pub struct Stage5SumcheckEvalPlan { pub oracle: String, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Stage5InstructionReadRafEmitPlan { + pub(crate) point: String, + pub(crate) lookup_output_point: String, + pub(crate) table_flag_evals: Stage5NamedEvalFamilyEmitPlan, + pub(crate) instruction_ra_evals: Stage5NamedEvalFamilyEmitPlan, + pub(crate) raf_flag_eval: String, + pub(crate) gamma: String, + pub(crate) log_k: usize, +} + +impl Stage5InstructionReadRafEmitPlan { + fn from_evals(evals: &[Stage5SumcheckEvalPlan]) -> Result { + Ok(Self { + point: "stage5.instruction_read_raf.point".to_owned(), + lookup_output_point: "stage5.input.stage2.instruction.LookupOutput".to_owned(), + table_flag_evals: Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( + "stage5.instruction_read_raf.eval.LookupTableFlag", + "LookupTableFlag_", + evals, + )?, + instruction_ra_evals: Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( + "stage5.instruction_read_raf.eval.InstructionRa", + "InstructionRa_", + evals, + )?, + raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag".to_owned(), + gamma: "stage5.instruction_read_raf.gamma".to_owned(), + log_k: 128, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Stage5NamedEvalFamilyEmitPlan { + pub(crate) symbol: String, + pub(crate) evals: Vec, +} + +impl Stage5NamedEvalFamilyEmitPlan { + fn from_indexed_oracles( + symbol: &str, + oracle_prefix: &str, + evals: &[Stage5SumcheckEvalPlan], + ) -> Result { + let mut indexed_names = Vec::new(); + for eval in evals { + let Some(suffix) = eval.oracle.strip_prefix(oracle_prefix) else { + continue; + }; + let index = suffix.parse::().map_err(|_| { + EmitError::new(format!( + "invalid indexed eval oracle `{}` for family `{symbol}`", + eval.oracle + )) + })?; + indexed_names.push((index, eval.name.clone())); + } + if indexed_names.is_empty() { + return Err(EmitError::new(format!("missing eval family `{symbol}`"))); + } + indexed_names.sort_by_key(|(index, _)| *index); + for (expected, (actual, _)) in indexed_names.iter().enumerate() { + if expected != *actual { + return Err(EmitError::new(format!( + "non-contiguous eval family `{symbol}` at index {actual}" + ))); + } + } + Ok(Self { + symbol: symbol.to_owned(), + evals: indexed_names + .into_iter() + .map(|(_, name)| name) + .collect::>(), + }) + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5PointSlicePlan { pub symbol: String, @@ -582,10 +662,16 @@ impl Stage5CpuProgram { } else { Vec::new() }; + let instruction_read_raf_plan = if role == Role::Verifier { + Some(Stage5InstructionReadRafEmitPlan::from_evals(&evals)?) + } else { + None + }; Ok(Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, role, + instruction_read_raf_plan, steps, transcript_squeezes, transcript_absorb_bytes, @@ -1875,25 +1961,27 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_named_eval_family_constants(&self) -> Result { - const FAMILIES: &[(&str, &str, &str, &str)] = &[ + let plan = self + .instruction_read_raf_plan + .as_ref() + .ok_or_else(|| EmitError::new("missing stage5 instruction read-RAF plan"))?; + let families = [ ( "STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVAL_NAMES", "STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS", - "stage5.instruction_read_raf.eval.LookupTableFlag", - "LookupTableFlag_", + &plan.table_flag_evals, ), ( "STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES", "STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS", - "stage5.instruction_read_raf.eval.InstructionRa", - "InstructionRa_", + &plan.instruction_ra_evals, ), ]; let mut source = String::new(); - for (names_const, family_const, family_symbol, oracle_prefix) in FAMILIES { - let names = self.indexed_eval_family_names(family_symbol, oracle_prefix)?; - let names_source = names + for (names_const, family_const, family) in families { + let names_source = family + .evals .iter() .map(|name| rust_str(name)) .collect::>() @@ -1908,61 +1996,32 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); &mut source, format_args!( "pub const {family_const}: NamedEvalFamilyPlan = NamedEvalFamilyPlan {{ symbol: {}, evals: {names_const} }};\n\n", - rust_str(family_symbol), + rust_str(&family.symbol), ), ); } - source.push_str( - "pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan {\n\ - \x20 point: \"stage5.instruction_read_raf.point\",\n\ - \x20 lookup_output_point: \"stage5.input.stage2.instruction.LookupOutput\",\n\ - \x20 table_flag_evals: &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS,\n\ - \x20 instruction_ra_evals: &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS,\n\ - \x20 raf_flag_eval: \"stage5.instruction_read_raf.eval.InstructionRafFlag\",\n\ - \x20 gamma: \"stage5.instruction_read_raf.gamma\",\n\ - \x20 log_k: 128,\n\ - };\n\n", + push_format( + &mut source, + format_args!( + "pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan {{\n\ + \x20 point: {},\n\ + \x20 lookup_output_point: {},\n\ + \x20 table_flag_evals: &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS,\n\ + \x20 instruction_ra_evals: &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS,\n\ + \x20 raf_flag_eval: {},\n\ + \x20 gamma: {},\n\ + \x20 log_k: {},\n\ + }};\n\n", + rust_str(&plan.point), + rust_str(&plan.lookup_output_point), + rust_str(&plan.raf_flag_eval), + rust_str(&plan.gamma), + plan.log_k, + ), ); Ok(source) } - fn indexed_eval_family_names( - &self, - family_symbol: &str, - oracle_prefix: &str, - ) -> Result, EmitError> { - let mut indexed_names = Vec::new(); - for eval in &self.evals { - let Some(suffix) = eval.oracle.strip_prefix(oracle_prefix) else { - continue; - }; - let index = suffix.parse::().map_err(|_| { - EmitError::new(format!( - "invalid indexed eval oracle `{}` for family `{family_symbol}`", - eval.oracle - )) - })?; - indexed_names.push((index, eval.name.as_str())); - } - if indexed_names.is_empty() { - return Err(EmitError::new(format!( - "missing eval family `{family_symbol}`" - ))); - } - indexed_names.sort_by_key(|(index, _)| *index); - for (expected, (actual, _)) in indexed_names.iter().enumerate() { - if expected != *actual { - return Err(EmitError::new(format!( - "non-contiguous eval family `{family_symbol}` at index {actual}" - ))); - } - } - Ok(indexed_names - .into_iter() - .map(|(_, name)| name) - .collect::>()) - } - fn emit_verifier_output_claim_constants(&self) -> Result { super::output_claims::emit_verifier_output_claim_constants( "Stage5", From 23c8654fb1bf7888529764f1dd42c5900ba6ae56 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 01:23:52 -0600 Subject: [PATCH 065/171] refactor(bolt): type output claim dependency graph --- .../protocols/jolt/verifier_output_claims.rs | 220 ++++++++++++++---- 1 file changed, 172 insertions(+), 48 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index c0278b5350..7258708129 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -537,7 +537,7 @@ where }) }) .collect::, EmitError>>()?; - let family_symbols = output_family_dependency_closure( + let dependencies = output_dependency_closure( &output_families_by_symbol, &output_product_families_by_symbol, &output_function_families_by_symbol, @@ -546,17 +546,17 @@ where ); let eval_families = output_families .iter() - .filter(|family| family_symbols.eval.contains(&family.symbol)) + .filter(|family| dependencies.contains_eval_family(&family.symbol)) .cloned() .collect(); let product_families = output_product_families .iter() - .filter(|family| family_symbols.product.contains(&family.symbol)) + .filter(|family| dependencies.contains_product_family(&family.symbol)) .cloned() .collect(); let function_families = output_function_families .iter() - .filter(|family| family_symbols.function.contains(&family.symbol)) + .filter(|family| dependencies.contains_function_family(&family.symbol)) .cloned() .collect(); Ok(SumcheckOutputClaimPlan { @@ -571,67 +571,191 @@ where .collect() } -struct OutputFamilyDependencyClosure { - eval: BTreeSet, - product: BTreeSet, - function: BTreeSet, +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] +enum OutputDependencyNode { + Field(String), + EvalFamily(String), + ProductFamily(String), + FunctionFamily(String), } -fn output_family_dependency_closure<'a, T>( +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] +enum OutputFamilyDependency { + Eval(String), + Product(String), + Function(String), +} + +#[derive(Default)] +struct OutputDependencyClosure { + families: BTreeSet, +} + +impl OutputDependencyClosure { + fn contains_eval_family(&self, symbol: &str) -> bool { + self.families + .iter() + .any(|family| matches!(family, OutputFamilyDependency::Eval(value) if value == symbol)) + } + + fn contains_product_family(&self, symbol: &str) -> bool { + self.families.iter().any( + |family| matches!(family, OutputFamilyDependency::Product(value) if value == symbol), + ) + } + + fn contains_function_family(&self, symbol: &str) -> bool { + self.families.iter().any( + |family| matches!(family, OutputFamilyDependency::Function(value) if value == symbol), + ) + } +} + +fn output_dependency_closure<'a, T>( output_families_by_symbol: &BTreeMap<&str, &SumcheckOutputEvalFamilyPlan>, output_product_families_by_symbol: &BTreeMap<&str, &SumcheckOutputProductFamilyPlan>, output_function_families_by_symbol: &BTreeMap<&str, &SumcheckOutputFunctionFamilyPlan>, field_exprs_by_symbol: &BTreeMap<&str, &T>, roots: impl Iterator, -) -> OutputFamilyDependencyClosure +) -> OutputDependencyClosure where T: FieldExprDependencies, { let mut visited = BTreeSet::new(); - let mut eval_families = BTreeSet::new(); - let mut product_families = BTreeSet::new(); - let mut function_families = BTreeSet::new(); - let mut stack = roots.map(str::to_owned).collect::>(); - while let Some(symbol) = stack.pop() { - if !visited.insert(symbol.clone()) { + let mut dependencies = OutputDependencyClosure::default(); + let mut stack = roots + .map(|symbol| { + output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + symbol, + ) + }) + .collect::>(); + while let Some(node) = stack.pop() { + if !visited.insert(node.clone()) { continue; } - if let Some(family) = output_families_by_symbol.get(symbol.as_str()) { - let _inserted = eval_families.insert(family.symbol.clone()); - stack.push(family.gamma.clone()); - stack.extend(family.evals.iter().cloned()); - stack.extend(family.shared_terms.iter().map(|term| term.factor.clone())); - stack.extend( - family - .item_terms - .iter() - .flat_map(|term| term.factors.iter().cloned()), - ); - } - if let Some(family) = output_product_families_by_symbol.get(symbol.as_str()) { - let _inserted = product_families.insert(family.symbol.clone()); - stack.extend(family.gamma.iter().cloned()); - for term in &family.terms { - stack.extend(term.evals.iter().cloned()); - stack.extend(term.factors.iter().cloned()); + match node { + OutputDependencyNode::Field(symbol) => { + let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { + continue; + }; + stack.extend(expr.operands().iter().map(|operand| { + output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + operand, + ) + })); } - } - if let Some(family) = output_function_families_by_symbol.get(symbol.as_str()) { - let _inserted = function_families.insert(family.symbol.clone()); - stack.extend(family.gamma.iter().cloned()); - for term in &family.terms { - stack.push(term.eval.clone()); - stack.extend(term.factors.iter().cloned()); + OutputDependencyNode::EvalFamily(symbol) => { + let Some(family) = output_families_by_symbol.get(symbol.as_str()) else { + continue; + }; + let _inserted = dependencies + .families + .insert(OutputFamilyDependency::Eval(family.symbol.clone())); + stack.push(OutputDependencyNode::Field(family.gamma.clone())); + stack.extend( + family + .evals + .iter() + .cloned() + .map(OutputDependencyNode::Field), + ); + stack.extend(family.shared_terms.iter().map(|term| { + output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + &term.factor, + ) + })); + stack.extend(family.item_terms.iter().flat_map(|term| { + term.factors.iter().map(|factor| { + output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + factor, + ) + }) + })); + } + OutputDependencyNode::ProductFamily(symbol) => { + let Some(family) = output_product_families_by_symbol.get(symbol.as_str()) else { + continue; + }; + let _inserted = dependencies + .families + .insert(OutputFamilyDependency::Product(family.symbol.clone())); + stack.extend( + family + .gamma + .iter() + .cloned() + .map(OutputDependencyNode::Field), + ); + for term in &family.terms { + stack.extend(term.evals.iter().cloned().map(OutputDependencyNode::Field)); + stack.extend(term.factors.iter().map(|factor| { + output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + factor, + ) + })); + } + } + OutputDependencyNode::FunctionFamily(symbol) => { + let Some(family) = output_function_families_by_symbol.get(symbol.as_str()) else { + continue; + }; + let _inserted = dependencies + .families + .insert(OutputFamilyDependency::Function(family.symbol.clone())); + stack.extend( + family + .gamma + .iter() + .cloned() + .map(OutputDependencyNode::Field), + ); + for term in &family.terms { + stack.push(OutputDependencyNode::Field(term.eval.clone())); + stack.extend(term.factors.iter().map(|factor| { + output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + factor, + ) + })); + } } - } - if let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) { - stack.extend(expr.operands().iter().cloned()); } } - OutputFamilyDependencyClosure { - eval: eval_families, - product: product_families, - function: function_families, + dependencies +} + +fn output_dependency_node( + output_families_by_symbol: &BTreeMap<&str, &SumcheckOutputEvalFamilyPlan>, + output_product_families_by_symbol: &BTreeMap<&str, &SumcheckOutputProductFamilyPlan>, + output_function_families_by_symbol: &BTreeMap<&str, &SumcheckOutputFunctionFamilyPlan>, + symbol: &str, +) -> OutputDependencyNode { + if output_families_by_symbol.contains_key(symbol) { + OutputDependencyNode::EvalFamily(symbol.to_owned()) + } else if output_product_families_by_symbol.contains_key(symbol) { + OutputDependencyNode::ProductFamily(symbol.to_owned()) + } else if output_function_families_by_symbol.contains_key(symbol) { + OutputDependencyNode::FunctionFamily(symbol.to_owned()) + } else { + OutputDependencyNode::Field(symbol.to_owned()) } } From 5329f30a8284c1eedc2bd17595d99eb534a19fbc Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 01:30:14 -0600 Subject: [PATCH 066/171] refactor(bolt): split output claim scalar nodes --- .../protocols/jolt/verifier_output_claims.rs | 91 +++++++++++++------ 1 file changed, 64 insertions(+), 27 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index 7258708129..31a3360fc4 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -573,7 +573,8 @@ where #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] enum OutputDependencyNode { - Field(String), + Scalar(String), + FieldExpr(String), EvalFamily(String), ProductFamily(String), FunctionFamily(String), @@ -629,6 +630,7 @@ where output_families_by_symbol, output_product_families_by_symbol, output_function_families_by_symbol, + field_exprs_by_symbol, symbol, ) }) @@ -638,7 +640,8 @@ where continue; } match node { - OutputDependencyNode::Field(symbol) => { + OutputDependencyNode::Scalar(_) => {} + OutputDependencyNode::FieldExpr(symbol) => { let Some(expr) = field_exprs_by_symbol.get(symbol.as_str()) else { continue; }; @@ -647,6 +650,7 @@ where output_families_by_symbol, output_product_families_by_symbol, output_function_families_by_symbol, + field_exprs_by_symbol, operand, ) })); @@ -658,19 +662,28 @@ where let _inserted = dependencies .families .insert(OutputFamilyDependency::Eval(family.symbol.clone())); - stack.push(OutputDependencyNode::Field(family.gamma.clone())); - stack.extend( - family - .evals - .iter() - .cloned() - .map(OutputDependencyNode::Field), - ); + stack.push(output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + field_exprs_by_symbol, + &family.gamma, + )); + stack.extend(family.evals.iter().map(|eval| { + output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + field_exprs_by_symbol, + eval, + ) + })); stack.extend(family.shared_terms.iter().map(|term| { output_dependency_node( output_families_by_symbol, output_product_families_by_symbol, output_function_families_by_symbol, + field_exprs_by_symbol, &term.factor, ) })); @@ -680,6 +693,7 @@ where output_families_by_symbol, output_product_families_by_symbol, output_function_families_by_symbol, + field_exprs_by_symbol, factor, ) }) @@ -692,20 +706,31 @@ where let _inserted = dependencies .families .insert(OutputFamilyDependency::Product(family.symbol.clone())); - stack.extend( - family - .gamma - .iter() - .cloned() - .map(OutputDependencyNode::Field), - ); + stack.extend(family.gamma.iter().map(|gamma| { + output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + field_exprs_by_symbol, + gamma, + ) + })); for term in &family.terms { - stack.extend(term.evals.iter().cloned().map(OutputDependencyNode::Field)); + stack.extend(term.evals.iter().map(|eval| { + output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + field_exprs_by_symbol, + eval, + ) + })); stack.extend(term.factors.iter().map(|factor| { output_dependency_node( output_families_by_symbol, output_product_families_by_symbol, output_function_families_by_symbol, + field_exprs_by_symbol, factor, ) })); @@ -718,20 +743,29 @@ where let _inserted = dependencies .families .insert(OutputFamilyDependency::Function(family.symbol.clone())); - stack.extend( - family - .gamma - .iter() - .cloned() - .map(OutputDependencyNode::Field), - ); + stack.extend(family.gamma.iter().map(|gamma| { + output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + field_exprs_by_symbol, + gamma, + ) + })); for term in &family.terms { - stack.push(OutputDependencyNode::Field(term.eval.clone())); + stack.push(output_dependency_node( + output_families_by_symbol, + output_product_families_by_symbol, + output_function_families_by_symbol, + field_exprs_by_symbol, + &term.eval, + )); stack.extend(term.factors.iter().map(|factor| { output_dependency_node( output_families_by_symbol, output_product_families_by_symbol, output_function_families_by_symbol, + field_exprs_by_symbol, factor, ) })); @@ -746,6 +780,7 @@ fn output_dependency_node( output_families_by_symbol: &BTreeMap<&str, &SumcheckOutputEvalFamilyPlan>, output_product_families_by_symbol: &BTreeMap<&str, &SumcheckOutputProductFamilyPlan>, output_function_families_by_symbol: &BTreeMap<&str, &SumcheckOutputFunctionFamilyPlan>, + field_exprs_by_symbol: &BTreeMap<&str, &impl FieldExprDependencies>, symbol: &str, ) -> OutputDependencyNode { if output_families_by_symbol.contains_key(symbol) { @@ -754,8 +789,10 @@ fn output_dependency_node( OutputDependencyNode::ProductFamily(symbol.to_owned()) } else if output_function_families_by_symbol.contains_key(symbol) { OutputDependencyNode::FunctionFamily(symbol.to_owned()) + } else if field_exprs_by_symbol.contains_key(symbol) { + OutputDependencyNode::FieldExpr(symbol.to_owned()) } else { - OutputDependencyNode::Field(symbol.to_owned()) + OutputDependencyNode::Scalar(symbol.to_owned()) } } From 0c17e7aa2276129d28d14ceac99957bf908dc0f8 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 01:36:49 -0600 Subject: [PATCH 067/171] refactor(bolt): type verifier value sources --- .../src/protocols/jolt/emit/rust/stage3.rs | 56 +++++++++----- .../src/protocols/jolt/emit/rust/stage4.rs | 54 ++++++++----- .../src/protocols/jolt/emit/rust/stage5.rs | 54 ++++++++----- .../src/protocols/jolt/emit/rust/stage6.rs | 76 +++++++++++++------ .../src/protocols/jolt/emit/rust/stage7.rs | 76 +++++++++++++------ .../protocols/jolt/verifier_output_claims.rs | 76 ++++++++++++++++++- 6 files changed, 289 insertions(+), 103 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 4588491bf2..b97dec6ef3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -824,36 +824,58 @@ impl Stage3CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> BTreeSet { - let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); - values.extend(symbols( + fn field_value_symbols(&self) -> verifier_output_claims::VerifierScalarSourceSet { + let mut values = verifier_output_claims::VerifierScalarSourceSet::default(); + values.extend( + self.opening_inputs.iter().map(|input| &input.symbol), + verifier_output_claims::VerifierScalarSourceKind::OpeningInput, + ); + values.extend( self.field_constants.iter().map(|constant| &constant.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::FieldConstant, + ); + values.extend( self.transcript_squeezes .iter() .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), - )); - values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); - values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::TranscriptScalar, + ); + values.extend( + self.field_exprs.iter().map(|expr| &expr.symbol), + verifier_output_claims::VerifierScalarSourceKind::FieldExpr, + ); + values.extend( + self.evals.iter().map(|eval| &eval.symbol), + verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, + ); + values.extend( self.output_values.iter().map(|value| &value.symbol), - )); + verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + ); values } - fn point_value_symbols(&self) -> BTreeSet { - let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); - values.extend(symbols( + fn point_value_symbols(&self) -> verifier_output_claims::VerifierPointSourceSet { + let mut values = verifier_output_claims::VerifierPointSourceSet::default(); + values.extend( + self.opening_inputs.iter().map(|input| &input.symbol), + verifier_output_claims::VerifierPointSourceKind::OpeningInput, + ); + values.extend( self.instance_results .iter() .map(|instance| &instance.symbol), - )); - values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - values.extend(symbols( + verifier_output_claims::VerifierPointSourceKind::SumcheckInstance, + ); + values.extend( + self.point_slices.iter().map(|slice| &slice.symbol), + verifier_output_claims::VerifierPointSourceKind::PointSlice, + ); + values.extend( self.point_concats.iter().map(|concat| &concat.symbol), - )); + verifier_output_claims::VerifierPointSourceKind::PointConcat, + ); values } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 8f2af01ef9..ea1aebc6c7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -854,38 +854,58 @@ impl Stage4CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> BTreeSet { - let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); - values.extend(symbols( + fn field_value_symbols(&self) -> verifier_output_claims::VerifierScalarSourceSet { + let mut values = verifier_output_claims::VerifierScalarSourceSet::default(); + values.extend( + self.opening_inputs.iter().map(|input| &input.symbol), + verifier_output_claims::VerifierScalarSourceKind::OpeningInput, + ); + values.extend( self.field_constants.iter().map(|constant| &constant.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::FieldConstant, + ); + values.extend( self.transcript_squeezes .iter() .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::TranscriptScalar, + ); + values.extend( self.output_values.iter().map(|value| &value.symbol), - )); - values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); - values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); + verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + ); + values.extend( + self.field_exprs.iter().map(|expr| &expr.symbol), + verifier_output_claims::VerifierScalarSourceKind::FieldExpr, + ); + values.extend( + self.evals.iter().map(|eval| &eval.symbol), + verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, + ); values } - fn point_value_symbols(&self) -> BTreeSet { - let mut values = symbols( + fn point_value_symbols(&self) -> verifier_output_claims::VerifierPointSourceSet { + let mut values = verifier_output_claims::VerifierPointSourceSet::default(); + values.extend( self.instance_results .iter() .map(|instance| &instance.symbol), + verifier_output_claims::VerifierPointSourceKind::SumcheckInstance, ); - values.extend(symbols( + values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - )); - values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - values.extend(symbols( + verifier_output_claims::VerifierPointSourceKind::OpeningInput, + ); + values.extend( + self.point_slices.iter().map(|slice| &slice.symbol), + verifier_output_claims::VerifierPointSourceKind::PointSlice, + ); + values.extend( self.point_concats.iter().map(|concat| &concat.symbol), - )); + verifier_output_claims::VerifierPointSourceKind::PointConcat, + ); values } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 6d4423fcff..fc0cddbca5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -775,38 +775,58 @@ impl Stage5CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> BTreeSet { - let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); - values.extend(symbols( + fn field_value_symbols(&self) -> verifier_output_claims::VerifierScalarSourceSet { + let mut values = verifier_output_claims::VerifierScalarSourceSet::default(); + values.extend( + self.opening_inputs.iter().map(|input| &input.symbol), + verifier_output_claims::VerifierScalarSourceKind::OpeningInput, + ); + values.extend( self.field_constants.iter().map(|constant| &constant.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::FieldConstant, + ); + values.extend( self.transcript_squeezes .iter() .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::TranscriptScalar, + ); + values.extend( self.output_values.iter().map(|value| &value.symbol), - )); - values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); - values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); + verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + ); + values.extend( + self.field_exprs.iter().map(|expr| &expr.symbol), + verifier_output_claims::VerifierScalarSourceKind::FieldExpr, + ); + values.extend( + self.evals.iter().map(|eval| &eval.symbol), + verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, + ); values } - fn point_value_symbols(&self) -> BTreeSet { - let mut values = symbols( + fn point_value_symbols(&self) -> verifier_output_claims::VerifierPointSourceSet { + let mut values = verifier_output_claims::VerifierPointSourceSet::default(); + values.extend( self.instance_results .iter() .map(|instance| &instance.symbol), + verifier_output_claims::VerifierPointSourceKind::SumcheckInstance, ); - values.extend(symbols( + values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - )); - values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - values.extend(symbols( + verifier_output_claims::VerifierPointSourceKind::OpeningInput, + ); + values.extend( + self.point_slices.iter().map(|slice| &slice.symbol), + verifier_output_claims::VerifierPointSourceKind::PointSlice, + ); + values.extend( self.point_concats.iter().map(|concat| &concat.symbol), - )); + verifier_output_claims::VerifierPointSourceKind::PointConcat, + ); values } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index b252183de5..5149ffb85b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -3,7 +3,7 @@ reason = "generated Rust templates are kept as raw string blocks for copyable output" )] -use std::collections::{BTreeMap, BTreeSet}; +use std::collections::BTreeMap; use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; @@ -756,52 +756,78 @@ impl Stage6CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> BTreeSet { - let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); - values.extend(symbols( + fn field_value_symbols(&self) -> verifier_output_claims::VerifierScalarSourceSet { + let mut values = verifier_output_claims::VerifierScalarSourceSet::default(); + values.extend( + self.opening_inputs.iter().map(|input| &input.symbol), + verifier_output_claims::VerifierScalarSourceKind::OpeningInput, + ); + values.extend( self.field_constants.iter().map(|constant| &constant.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::FieldConstant, + ); + values.extend( self.transcript_squeezes .iter() .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::TranscriptScalar, + ); + values.extend( self.output_values.iter().map(|value| &value.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + ); + values.extend( self.output_families.iter().map(|family| &family.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, + ); + values.extend( self.output_product_families .iter() .map(|family| &family.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::OutputProductFamily, + ); + values.extend( self.output_function_families .iter() .map(|family| &family.symbol), - )); - values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); - values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); + verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, + ); + values.extend( + self.field_exprs.iter().map(|expr| &expr.symbol), + verifier_output_claims::VerifierScalarSourceKind::FieldExpr, + ); + values.extend( + self.evals.iter().map(|eval| &eval.symbol), + verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, + ); values } - fn point_value_symbols(&self) -> BTreeSet { - let mut values = symbols( + fn point_value_symbols(&self) -> verifier_output_claims::VerifierPointSourceSet { + let mut values = verifier_output_claims::VerifierPointSourceSet::default(); + values.extend( self.instance_results .iter() .map(|instance| &instance.symbol), + verifier_output_claims::VerifierPointSourceKind::SumcheckInstance, ); - values.extend(symbols( + values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - )); - values.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); - values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - values.extend(symbols( + verifier_output_claims::VerifierPointSourceKind::OpeningInput, + ); + values.extend( + self.point_zeros.iter().map(|zero| &zero.symbol), + verifier_output_claims::VerifierPointSourceKind::PointZero, + ); + values.extend( + self.point_slices.iter().map(|slice| &slice.symbol), + verifier_output_claims::VerifierPointSourceKind::PointSlice, + ); + values.extend( self.point_concats.iter().map(|concat| &concat.symbol), - )); + verifier_output_claims::VerifierPointSourceKind::PointConcat, + ); values } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index b221179e9c..fdd13ae42e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -3,7 +3,7 @@ reason = "generated Rust templates are kept as raw string blocks for copyable output" )] -use std::collections::{BTreeMap, BTreeSet}; +use std::collections::BTreeMap; use melior::ir::block::BlockLike; use melior::ir::operation::{OperationLike, OperationResult}; @@ -741,52 +741,78 @@ impl Stage7CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> BTreeSet { - let mut values = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); - values.extend(symbols( + fn field_value_symbols(&self) -> verifier_output_claims::VerifierScalarSourceSet { + let mut values = verifier_output_claims::VerifierScalarSourceSet::default(); + values.extend( + self.opening_inputs.iter().map(|input| &input.symbol), + verifier_output_claims::VerifierScalarSourceKind::OpeningInput, + ); + values.extend( self.field_constants.iter().map(|constant| &constant.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::FieldConstant, + ); + values.extend( self.transcript_squeezes .iter() .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), - )); - values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); - values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::TranscriptScalar, + ); + values.extend( + self.field_exprs.iter().map(|expr| &expr.symbol), + verifier_output_claims::VerifierScalarSourceKind::FieldExpr, + ); + values.extend( + self.evals.iter().map(|eval| &eval.symbol), + verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, + ); + values.extend( self.output_values.iter().map(|value| &value.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + ); + values.extend( self.output_families.iter().map(|family| &family.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, + ); + values.extend( self.output_product_families .iter() .map(|family| &family.symbol), - )); - values.extend(symbols( + verifier_output_claims::VerifierScalarSourceKind::OutputProductFamily, + ); + values.extend( self.output_function_families .iter() .map(|family| &family.symbol), - )); + verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, + ); values } - fn point_value_symbols(&self) -> BTreeSet { - let mut values = symbols( + fn point_value_symbols(&self) -> verifier_output_claims::VerifierPointSourceSet { + let mut values = verifier_output_claims::VerifierPointSourceSet::default(); + values.extend( self.instance_results .iter() .map(|instance| &instance.symbol), + verifier_output_claims::VerifierPointSourceKind::SumcheckInstance, ); - values.extend(symbols( + values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - )); - values.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); - values.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - values.extend(symbols( + verifier_output_claims::VerifierPointSourceKind::OpeningInput, + ); + values.extend( + self.point_zeros.iter().map(|zero| &zero.symbol), + verifier_output_claims::VerifierPointSourceKind::PointZero, + ); + values.extend( + self.point_slices.iter().map(|slice| &slice.symbol), + verifier_output_claims::VerifierPointSourceKind::PointSlice, + ); + values.extend( self.point_concats.iter().map(|concat| &concat.symbol), - )); + verifier_output_claims::VerifierPointSourceKind::PointConcat, + ); values } diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index 31a3360fc4..8206ca69b4 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -474,6 +474,78 @@ pub trait FieldExprDependencies { fn operands(&self) -> &[String]; } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum VerifierScalarSourceKind { + OpeningInput, + FieldConstant, + TranscriptScalar, + FieldExpr, + SumcheckEval, + StructuredPolynomialEval, + OutputEvalFamily, + OutputProductFamily, + OutputFunctionFamily, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct VerifierScalarSourceSet { + symbols: BTreeMap, +} + +impl VerifierScalarSourceSet { + pub fn insert(&mut self, symbol: &str, kind: VerifierScalarSourceKind) { + let _old = self.symbols.insert(symbol.to_owned(), kind); + } + + pub fn extend<'a>( + &mut self, + symbols: impl IntoIterator, + kind: VerifierScalarSourceKind, + ) { + for symbol in symbols { + self.insert(symbol, kind); + } + } + + pub fn contains(&self, symbol: &str) -> bool { + self.symbols.contains_key(symbol) + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum VerifierPointSourceKind { + OpeningInput, + SumcheckInstance, + PointZero, + PointSlice, + PointConcat, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct VerifierPointSourceSet { + symbols: BTreeMap, +} + +impl VerifierPointSourceSet { + pub fn insert(&mut self, symbol: &str, kind: VerifierPointSourceKind) { + let _old = self.symbols.insert(symbol.to_owned(), kind); + } + + pub fn extend<'a>( + &mut self, + symbols: impl IntoIterator, + kind: VerifierPointSourceKind, + ) { + for symbol in symbols { + self.insert(symbol, kind); + } + } + + pub fn contains(&self, symbol: &str) -> bool { + self.symbols.contains_key(symbol) + } +} + pub fn resolve_output_claims( stage: &str, output_values: &[StructuredPolynomialEvalPlan], @@ -824,8 +896,8 @@ pub struct OutputClaimVerification<'a> { pub output_function_families: &'a [SumcheckOutputFunctionFamilyPlan], pub output_claims: &'a [SumcheckOutputClaimPlan], pub relations: &'a BTreeSet, - pub field_values: &'a BTreeSet, - pub point_values: &'a BTreeSet, + pub field_values: &'a VerifierScalarSourceSet, + pub point_values: &'a VerifierPointSourceSet, } pub fn verify_output_claims( From 83392c75fe69c216f9fa557c241621052e740f60 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 01:42:40 -0600 Subject: [PATCH 068/171] refactor(bolt): reject value source conflicts --- .../protocols/jolt/verifier_output_claims.rs | 155 +++++++++++++++++- 1 file changed, 148 insertions(+), 7 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index 8206ca69b4..14905e2a83 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -490,11 +490,26 @@ pub enum VerifierScalarSourceKind { #[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct VerifierScalarSourceSet { symbols: BTreeMap, + conflicts: Vec>, } impl VerifierScalarSourceSet { pub fn insert(&mut self, symbol: &str, kind: VerifierScalarSourceKind) { - let _old = self.symbols.insert(symbol.to_owned(), kind); + match self.symbols.entry(symbol.to_owned()) { + std::collections::btree_map::Entry::Vacant(entry) => { + let _entry = entry.insert(kind); + } + std::collections::btree_map::Entry::Occupied(entry) => { + let existing = *entry.get(); + if existing != kind { + self.conflicts.push(VerifierSourceConflict { + symbol: symbol.to_owned(), + existing, + incoming: kind, + }); + } + } + } } pub fn extend<'a>( @@ -510,6 +525,13 @@ impl VerifierScalarSourceSet { pub fn contains(&self, symbol: &str) -> bool { self.symbols.contains_key(symbol) } + + fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { + let Some(conflict) = self.conflicts.first() else { + return Ok(()); + }; + Err(conflicting_source_error(stage, "scalar", conflict)) + } } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -524,11 +546,26 @@ pub enum VerifierPointSourceKind { #[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct VerifierPointSourceSet { symbols: BTreeMap, + conflicts: Vec>, } impl VerifierPointSourceSet { pub fn insert(&mut self, symbol: &str, kind: VerifierPointSourceKind) { - let _old = self.symbols.insert(symbol.to_owned(), kind); + match self.symbols.entry(symbol.to_owned()) { + std::collections::btree_map::Entry::Vacant(entry) => { + let _entry = entry.insert(kind); + } + std::collections::btree_map::Entry::Occupied(entry) => { + let existing = *entry.get(); + if existing != kind { + self.conflicts.push(VerifierSourceConflict { + symbol: symbol.to_owned(), + existing, + incoming: kind, + }); + } + } + } } pub fn extend<'a>( @@ -544,6 +581,34 @@ impl VerifierPointSourceSet { pub fn contains(&self, symbol: &str) -> bool { self.symbols.contains_key(symbol) } + + fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { + let Some(conflict) = self.conflicts.first() else { + return Ok(()); + }; + Err(conflicting_source_error(stage, "point", conflict)) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct VerifierSourceConflict { + symbol: String, + existing: K, + incoming: K, +} + +fn conflicting_source_error( + stage: &str, + value_kind: &str, + conflict: &VerifierSourceConflict, +) -> EmitError +where + K: std::fmt::Debug, +{ + EmitError::new(format!( + "{stage} {value_kind} source @{} has conflicting kinds {:?} and {:?}", + conflict.symbol, conflict.existing, conflict.incoming + )) } pub fn resolve_output_claims( @@ -914,6 +979,8 @@ pub fn verify_output_claims( field_values, point_values, } = verification; + field_values.verify_no_conflicts(stage)?; + point_values.verify_no_conflicts(stage)?; for polynomial_eval in output_values { if !point_values.contains(&polynomial_eval.x_point.source) { return Err(EmitError::new(format!( @@ -1227,14 +1294,18 @@ fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> Em #[cfg(test)] mod tests { + use std::collections::BTreeSet; + use crate::emit::rust::EmitError; use super::{ - resolve_output_claims, FieldExprDependencies, SumcheckOutputClaimAst, - SumcheckOutputEvalFamilyItemTermPlan, SumcheckOutputEvalFamilyPlan, - SumcheckOutputEvalFamilySharedTermPlan, SumcheckOutputFunctionFamilyPlan, - SumcheckOutputFunctionFamilyTermPlan, SumcheckOutputFunctionKind, - SumcheckOutputProductFamilyPlan, SumcheckOutputProductFamilyTermPlan, + resolve_output_claims, verify_output_claims, FieldExprDependencies, + OutputClaimVerification, SumcheckOutputClaimAst, SumcheckOutputEvalFamilyItemTermPlan, + SumcheckOutputEvalFamilyPlan, SumcheckOutputEvalFamilySharedTermPlan, + SumcheckOutputFunctionFamilyPlan, SumcheckOutputFunctionFamilyTermPlan, + SumcheckOutputFunctionKind, SumcheckOutputProductFamilyPlan, + SumcheckOutputProductFamilyTermPlan, VerifierPointSourceKind, VerifierPointSourceSet, + VerifierScalarSourceKind, VerifierScalarSourceSet, }; struct TestFieldExpr { @@ -1420,4 +1491,74 @@ mod tests { assert_eq!(family_symbols, vec!["function.family"]); Ok(()) } + + #[test] + fn output_claim_verification_rejects_conflicting_scalar_sources() -> Result<(), EmitError> { + let mut field_values = VerifierScalarSourceSet::default(); + field_values.insert("value", VerifierScalarSourceKind::OpeningInput); + field_values.insert("value", VerifierScalarSourceKind::FieldExpr); + let point_values = VerifierPointSourceSet::default(); + let relations = BTreeSet::new(); + + let error = match verify_output_claims( + "stage", + OutputClaimVerification { + output_values: &[], + output_families: &[], + output_product_families: &[], + output_function_families: &[], + output_claims: &[], + relations: &relations, + field_values: &field_values, + point_values: &point_values, + }, + ) { + Ok(()) => { + return Err(EmitError::new( + "conflicting scalar sources should fail verification", + )); + } + Err(error) => error, + }; + + assert!(error.to_string().contains( + "stage scalar source @value has conflicting kinds OpeningInput and FieldExpr" + )); + Ok(()) + } + + #[test] + fn output_claim_verification_rejects_conflicting_point_sources() -> Result<(), EmitError> { + let field_values = VerifierScalarSourceSet::default(); + let mut point_values = VerifierPointSourceSet::default(); + point_values.insert("point", VerifierPointSourceKind::OpeningInput); + point_values.insert("point", VerifierPointSourceKind::PointSlice); + let relations = BTreeSet::new(); + + let error = match verify_output_claims( + "stage", + OutputClaimVerification { + output_values: &[], + output_families: &[], + output_product_families: &[], + output_function_families: &[], + output_claims: &[], + relations: &relations, + field_values: &field_values, + point_values: &point_values, + }, + ) { + Ok(()) => { + return Err(EmitError::new( + "conflicting point sources should fail verification", + )); + } + Err(error) => error, + }; + + assert!(error.to_string().contains( + "stage point source @point has conflicting kinds OpeningInput and PointSlice" + )); + Ok(()) + } } From 60a8524dfc994fe9ce3d8794f9e64cf8d5f05aba Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 01:50:03 -0600 Subject: [PATCH 069/171] refactor(bolt): extract stage5 read raf plan --- .../src/protocols/jolt/emit/rust/stage5.rs | 142 +----------- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../jolt/stage5_instruction_read_raf_plan.rs | 214 ++++++++++++++++++ 3 files changed, 222 insertions(+), 135 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index fc0cddbca5..c5f983012b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -11,6 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionReadRafEmitPlan; use crate::protocols::jolt::verifier_output_claims::{ self, FieldExprDependencies, StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, @@ -187,85 +188,6 @@ pub struct Stage5SumcheckEvalPlan { pub oracle: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct Stage5InstructionReadRafEmitPlan { - pub(crate) point: String, - pub(crate) lookup_output_point: String, - pub(crate) table_flag_evals: Stage5NamedEvalFamilyEmitPlan, - pub(crate) instruction_ra_evals: Stage5NamedEvalFamilyEmitPlan, - pub(crate) raf_flag_eval: String, - pub(crate) gamma: String, - pub(crate) log_k: usize, -} - -impl Stage5InstructionReadRafEmitPlan { - fn from_evals(evals: &[Stage5SumcheckEvalPlan]) -> Result { - Ok(Self { - point: "stage5.instruction_read_raf.point".to_owned(), - lookup_output_point: "stage5.input.stage2.instruction.LookupOutput".to_owned(), - table_flag_evals: Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( - "stage5.instruction_read_raf.eval.LookupTableFlag", - "LookupTableFlag_", - evals, - )?, - instruction_ra_evals: Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( - "stage5.instruction_read_raf.eval.InstructionRa", - "InstructionRa_", - evals, - )?, - raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag".to_owned(), - gamma: "stage5.instruction_read_raf.gamma".to_owned(), - log_k: 128, - }) - } -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct Stage5NamedEvalFamilyEmitPlan { - pub(crate) symbol: String, - pub(crate) evals: Vec, -} - -impl Stage5NamedEvalFamilyEmitPlan { - fn from_indexed_oracles( - symbol: &str, - oracle_prefix: &str, - evals: &[Stage5SumcheckEvalPlan], - ) -> Result { - let mut indexed_names = Vec::new(); - for eval in evals { - let Some(suffix) = eval.oracle.strip_prefix(oracle_prefix) else { - continue; - }; - let index = suffix.parse::().map_err(|_| { - EmitError::new(format!( - "invalid indexed eval oracle `{}` for family `{symbol}`", - eval.oracle - )) - })?; - indexed_names.push((index, eval.name.clone())); - } - if indexed_names.is_empty() { - return Err(EmitError::new(format!("missing eval family `{symbol}`"))); - } - indexed_names.sort_by_key(|(index, _)| *index); - for (expected, (actual, _)) in indexed_names.iter().enumerate() { - if expected != *actual { - return Err(EmitError::new(format!( - "non-contiguous eval family `{symbol}` at index {actual}" - ))); - } - } - Ok(Self { - symbol: symbol.to_owned(), - evals: indexed_names - .into_iter() - .map(|(_, name)| name) - .collect::>(), - }) - } -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5PointSlicePlan { pub symbol: String, @@ -663,7 +585,11 @@ impl Stage5CpuProgram { Vec::new() }; let instruction_read_raf_plan = if role == Role::Verifier { - Some(Stage5InstructionReadRafEmitPlan::from_evals(&evals)?) + Some(Stage5InstructionReadRafEmitPlan::from_evals( + evals + .iter() + .map(|eval| (eval.oracle.as_str(), eval.name.as_str())), + )?) } else { None }; @@ -1985,61 +1911,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); .instruction_read_raf_plan .as_ref() .ok_or_else(|| EmitError::new("missing stage5 instruction read-RAF plan"))?; - let families = [ - ( - "STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVAL_NAMES", - "STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS", - &plan.table_flag_evals, - ), - ( - "STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES", - "STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS", - &plan.instruction_ra_evals, - ), - ]; - - let mut source = String::new(); - for (names_const, family_const, family) in families { - let names_source = family - .evals - .iter() - .map(|name| rust_str(name)) - .collect::>() - .join(", "); - push_format( - &mut source, - format_args!( - "#[rustfmt::skip]\npub const {names_const}: &[&str] = &[{names_source}];\n" - ), - ); - push_format( - &mut source, - format_args!( - "pub const {family_const}: NamedEvalFamilyPlan = NamedEvalFamilyPlan {{ symbol: {}, evals: {names_const} }};\n\n", - rust_str(&family.symbol), - ), - ); - } - push_format( - &mut source, - format_args!( - "pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan {{\n\ - \x20 point: {},\n\ - \x20 lookup_output_point: {},\n\ - \x20 table_flag_evals: &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS,\n\ - \x20 instruction_ra_evals: &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS,\n\ - \x20 raf_flag_eval: {},\n\ - \x20 gamma: {},\n\ - \x20 log_k: {},\n\ - }};\n\n", - rust_str(&plan.point), - rust_str(&plan.lookup_output_point), - rust_str(&plan.raf_flag_eval), - rust_str(&plan.gamma), - plan.log_k, - ), - ); - Ok(source) + Ok(plan.emit_runtime_constants()) } fn emit_verifier_output_claim_constants(&self) -> Result { diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index 85c0da4842..c220309775 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -4,6 +4,7 @@ pub mod oracles; pub mod params; pub mod phases; pub(crate) mod rust_target_plan; +pub(crate) mod stage5_instruction_read_raf_plan; pub(crate) mod stage6_bytecode_read_raf_plan; pub mod validate; pub(crate) mod verifier_output_claims; diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs new file mode 100644 index 0000000000..81dd91944b --- /dev/null +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -0,0 +1,214 @@ +use crate::emit::rust::{push_format, EmitError}; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Stage5InstructionReadRafEmitPlan { + pub(crate) point: String, + pub(crate) lookup_output_point: String, + pub(crate) table_flag_evals: Stage5NamedEvalFamilyEmitPlan, + pub(crate) instruction_ra_evals: Stage5NamedEvalFamilyEmitPlan, + pub(crate) raf_flag_eval: String, + pub(crate) gamma: String, + pub(crate) log_k: usize, +} + +impl Stage5InstructionReadRafEmitPlan { + pub(crate) fn from_evals<'a>( + evals: impl IntoIterator, + ) -> Result { + let evals = evals.into_iter().collect::>(); + Ok(Self { + point: "stage5.instruction_read_raf.point".to_owned(), + lookup_output_point: "stage5.input.stage2.instruction.LookupOutput".to_owned(), + table_flag_evals: Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( + "stage5.instruction_read_raf.eval.LookupTableFlag", + "LookupTableFlag_", + evals.iter().copied(), + )?, + instruction_ra_evals: Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( + "stage5.instruction_read_raf.eval.InstructionRa", + "InstructionRa_", + evals.iter().copied(), + )?, + raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag".to_owned(), + gamma: "stage5.instruction_read_raf.gamma".to_owned(), + log_k: 128, + }) + } + + pub(crate) fn emit_runtime_constants(&self) -> String { + let families = [ + ( + "STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVAL_NAMES", + "STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS", + &self.table_flag_evals, + ), + ( + "STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES", + "STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS", + &self.instruction_ra_evals, + ), + ]; + + let mut source = String::new(); + for (names_const, family_const, family) in families { + let names_source = family + .evals + .iter() + .map(|name| rust_str(name)) + .collect::>() + .join(", "); + push_format( + &mut source, + format_args!( + "#[rustfmt::skip]\npub const {names_const}: &[&str] = &[{names_source}];\n" + ), + ); + push_format( + &mut source, + format_args!( + "pub const {family_const}: NamedEvalFamilyPlan = NamedEvalFamilyPlan {{ symbol: {}, evals: {names_const} }};\n\n", + rust_str(&family.symbol), + ), + ); + } + push_format( + &mut source, + format_args!( + "pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan {{\n\ + \x20 point: {},\n\ + \x20 lookup_output_point: {},\n\ + \x20 table_flag_evals: &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS,\n\ + \x20 instruction_ra_evals: &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS,\n\ + \x20 raf_flag_eval: {},\n\ + \x20 gamma: {},\n\ + \x20 log_k: {},\n\ + }};\n\n", + rust_str(&self.point), + rust_str(&self.lookup_output_point), + rust_str(&self.raf_flag_eval), + rust_str(&self.gamma), + self.log_k, + ), + ); + source + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Stage5NamedEvalFamilyEmitPlan { + pub(crate) symbol: String, + pub(crate) evals: Vec, +} + +impl Stage5NamedEvalFamilyEmitPlan { + fn from_indexed_oracles<'a>( + symbol: &str, + oracle_prefix: &str, + evals: impl IntoIterator, + ) -> Result { + let mut indexed_names = Vec::new(); + for (oracle, name) in evals { + let Some(suffix) = oracle.strip_prefix(oracle_prefix) else { + continue; + }; + let index = suffix.parse::().map_err(|_| { + EmitError::new(format!( + "invalid indexed eval oracle `{oracle}` for family `{symbol}`" + )) + })?; + indexed_names.push((index, name.to_owned())); + } + if indexed_names.is_empty() { + return Err(EmitError::new(format!("missing eval family `{symbol}`"))); + } + indexed_names.sort_by_key(|(index, _)| *index); + for (expected, (actual, _)) in indexed_names.iter().enumerate() { + if expected != *actual { + return Err(EmitError::new(format!( + "non-contiguous eval family `{symbol}` at index {actual}" + ))); + } + } + Ok(Self { + symbol: symbol.to_owned(), + evals: indexed_names + .into_iter() + .map(|(_, name)| name) + .collect::>(), + }) + } +} + +fn rust_str(value: &str) -> String { + format!("{value:?}") +} + +#[cfg(test)] +mod tests { + use crate::emit::rust::EmitError; + + use super::Stage5InstructionReadRafEmitPlan; + + #[test] + fn instruction_read_raf_plan_groups_indexed_eval_families() -> Result<(), EmitError> { + let plan = Stage5InstructionReadRafEmitPlan::from_evals([ + ( + "LookupTableFlag_1", + "stage5.instruction_read_raf.eval.LookupTableFlag_1", + ), + ( + "InstructionRafFlag", + "stage5.instruction_read_raf.eval.InstructionRafFlag", + ), + ( + "InstructionRa_0", + "stage5.instruction_read_raf.eval.InstructionRa_0", + ), + ( + "LookupTableFlag_0", + "stage5.instruction_read_raf.eval.LookupTableFlag_0", + ), + ])?; + + assert_eq!( + plan.table_flag_evals.evals, + vec![ + "stage5.instruction_read_raf.eval.LookupTableFlag_0", + "stage5.instruction_read_raf.eval.LookupTableFlag_1" + ] + ); + assert_eq!( + plan.instruction_ra_evals.evals, + vec!["stage5.instruction_read_raf.eval.InstructionRa_0"] + ); + Ok(()) + } + + #[test] + fn instruction_read_raf_plan_rejects_non_contiguous_eval_families() -> Result<(), EmitError> { + let error = match Stage5InstructionReadRafEmitPlan::from_evals([ + ( + "LookupTableFlag_1", + "stage5.instruction_read_raf.eval.LookupTableFlag_1", + ), + ( + "InstructionRa_0", + "stage5.instruction_read_raf.eval.InstructionRa_0", + ), + ]) { + Ok(_) => { + return Err(EmitError::new( + "non-contiguous table flag family should fail planning", + )); + } + Err(error) => error, + }; + + assert!( + error + .to_string() + .contains("non-contiguous eval family `stage5.instruction_read_raf.eval.LookupTableFlag` at index 1") + ); + Ok(()) + } +} From 1e3a83f4763fd83e416945af8925c0a958c3270f Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 01:53:22 -0600 Subject: [PATCH 070/171] refactor(bolt): plumb stage5 output families --- .../src/protocols/jolt/emit/rust/stage5.rs | 52 ++++++++++++++++--- 1 file changed, 45 insertions(+), 7 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index c5f983012b..a8309a6cae 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -13,11 +13,15 @@ use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionReadRafEmitPlan; use crate::protocols::jolt::verifier_output_claims::{ - self, FieldExprDependencies, + self, parse_output_eval_family_plan, parse_output_function_family_plan, + parse_output_product_family_plan, FieldExprDependencies, StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, SumcheckOutputClaimAst as Stage5SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage5SumcheckOutputClaimPlan, + SumcheckOutputEvalFamilyPlan as Stage5SumcheckOutputEvalFamilyPlan, + SumcheckOutputFunctionFamilyPlan as Stage5SumcheckOutputFunctionFamilyPlan, + SumcheckOutputProductFamilyPlan as Stage5SumcheckOutputProductFamilyPlan, }; use crate::schema::verify_cpu_schema; @@ -39,6 +43,9 @@ pub struct Stage5CpuProgram { pub instance_results: Vec, pub evals: Vec, pub output_values: Vec, + pub output_families: Vec, + pub output_product_families: Vec, + pub output_function_families: Vec, pub output_claims: Vec, pub point_slices: Vec, pub point_concats: Vec, @@ -267,6 +274,9 @@ impl Stage5CpuProgram { let mut instance_results = Vec::new(); let mut evals = Vec::new(); let mut output_values = Vec::new(); + let mut output_families = Vec::new(); + let mut output_product_families = Vec::new(); + let mut output_function_families = Vec::new(); let mut output_claim_asts = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); @@ -500,6 +510,15 @@ impl Stage5CpuProgram { y_point, )?); } + "cpu.sumcheck_output_eval_family" => { + output_families.push(parse_output_eval_family_plan("stage5", op)?); + } + "cpu.sumcheck_output_product_family" => { + output_product_families.push(parse_output_product_family_plan("stage5", op)?); + } + "cpu.sumcheck_output_function_family" => { + output_function_families.push(parse_output_function_family_plan("stage5", op)?); + } "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage5SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, @@ -575,9 +594,9 @@ impl Stage5CpuProgram { verifier_output_claims::resolve_output_claims( "stage5", &output_values, - &[], - &[], - &[], + &output_families, + &output_product_families, + &output_function_families, &field_exprs, output_claim_asts, )? @@ -611,6 +630,9 @@ impl Stage5CpuProgram { instance_results, evals, output_values, + output_families, + output_product_families, + output_function_families, output_claims, point_slices, point_concats, @@ -722,6 +744,22 @@ impl Stage5CpuProgram { self.output_values.iter().map(|value| &value.symbol), verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, ); + values.extend( + self.output_families.iter().map(|family| &family.symbol), + verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, + ); + values.extend( + self.output_product_families + .iter() + .map(|family| &family.symbol), + verifier_output_claims::VerifierScalarSourceKind::OutputProductFamily, + ); + values.extend( + self.output_function_families + .iter() + .map(|family| &family.symbol), + verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, + ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), verifier_output_claims::VerifierScalarSourceKind::FieldExpr, @@ -941,9 +979,9 @@ impl Stage5CpuProgram { "stage5", verifier_output_claims::OutputClaimVerification { output_values: &self.output_values, - output_families: &[], - output_product_families: &[], - output_function_families: &[], + output_families: &self.output_families, + output_product_families: &self.output_product_families, + output_function_families: &self.output_function_families, output_claims: &self.output_claims, relations: &relations, field_values: &field_values, From 4d1925c2a32d41f3004c0d1350b33572498fe80a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 02:01:01 -0600 Subject: [PATCH 071/171] refactor(bolt): plan stage5 read raf values --- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../jolt/stage5_instruction_read_raf_plan.rs | 98 ++++++++++-- .../jolt/verifier_jolt_relations.rs.template | 148 +++++++++++++++--- .../src/stages/jolt_relations.rs | 148 +++++++++++++++--- crates/jolt-verifier/src/stages/stage5.rs | 50 +++++- 5 files changed, 396 insertions(+), 50 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index a8309a6cae..5463d7423e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1155,7 +1155,7 @@ impl Stage5CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan, NamedEvalFamilyPlan};\n\ - use super::jolt_relations::{evaluate_stage5_instruction_read_raf, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan};\n\ + use super::jolt_relations::{evaluate_stage5_instruction_read_raf, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 81dd91944b..2cd28a5c61 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -8,6 +8,7 @@ pub(crate) struct Stage5InstructionReadRafEmitPlan { pub(crate) instruction_ra_evals: Stage5NamedEvalFamilyEmitPlan, pub(crate) raf_flag_eval: String, pub(crate) gamma: String, + pub(crate) point_values: Vec, pub(crate) log_k: usize, } @@ -16,19 +17,22 @@ impl Stage5InstructionReadRafEmitPlan { evals: impl IntoIterator, ) -> Result { let evals = evals.into_iter().collect::>(); + let table_flag_evals = Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( + "stage5.instruction_read_raf.eval.LookupTableFlag", + "LookupTableFlag_", + evals.iter().copied(), + )?; + let instruction_ra_evals = Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( + "stage5.instruction_read_raf.eval.InstructionRa", + "InstructionRa_", + evals.iter().copied(), + )?; Ok(Self { point: "stage5.instruction_read_raf.point".to_owned(), lookup_output_point: "stage5.input.stage2.instruction.LookupOutput".to_owned(), - table_flag_evals: Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( - "stage5.instruction_read_raf.eval.LookupTableFlag", - "LookupTableFlag_", - evals.iter().copied(), - )?, - instruction_ra_evals: Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( - "stage5.instruction_read_raf.eval.InstructionRa", - "InstructionRa_", - evals.iter().copied(), - )?, + point_values: point_value_plans(table_flag_evals.evals.len()), + table_flag_evals, + instruction_ra_evals, raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag".to_owned(), gamma: "stage5.instruction_read_raf.gamma".to_owned(), log_k: 128, @@ -71,6 +75,7 @@ impl Stage5InstructionReadRafEmitPlan { ), ); } + source.push_str(&emit_point_value_constants(&self.point_values)); push_format( &mut source, format_args!( @@ -81,6 +86,7 @@ impl Stage5InstructionReadRafEmitPlan { \x20 instruction_ra_evals: &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS,\n\ \x20 raf_flag_eval: {},\n\ \x20 gamma: {},\n\ + \x20 point_values: STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES,\n\ \x20 log_k: {},\n\ }};\n\n", rust_str(&self.point), @@ -94,6 +100,20 @@ impl Stage5InstructionReadRafEmitPlan { } } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Stage5InstructionReadRafPointValueEmitPlan { + pub(crate) symbol: String, + pub(crate) kind: Stage5InstructionReadRafPointValueKind, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum Stage5InstructionReadRafPointValueKind { + LookupTable { index: usize }, + LeftOperand, + RightOperand, + Identity, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Stage5NamedEvalFamilyEmitPlan { pub(crate) symbol: String, @@ -139,6 +159,64 @@ impl Stage5NamedEvalFamilyEmitPlan { } } +fn point_value_plans(table_count: usize) -> Vec { + let mut values = (0..table_count) + .map(|index| Stage5InstructionReadRafPointValueEmitPlan { + symbol: format!("stage5.instruction_read_raf.point_value.LookupTable_{index}"), + kind: Stage5InstructionReadRafPointValueKind::LookupTable { index }, + }) + .collect::>(); + values.extend([ + Stage5InstructionReadRafPointValueEmitPlan { + symbol: "stage5.instruction_read_raf.point_value.LeftLookupOperand".to_owned(), + kind: Stage5InstructionReadRafPointValueKind::LeftOperand, + }, + Stage5InstructionReadRafPointValueEmitPlan { + symbol: "stage5.instruction_read_raf.point_value.RightLookupOperand".to_owned(), + kind: Stage5InstructionReadRafPointValueKind::RightOperand, + }, + Stage5InstructionReadRafPointValueEmitPlan { + symbol: "stage5.instruction_read_raf.point_value.Identity".to_owned(), + kind: Stage5InstructionReadRafPointValueKind::Identity, + }, + ]); + values +} + +fn emit_point_value_constants(values: &[Stage5InstructionReadRafPointValueEmitPlan]) -> String { + let values = values + .iter() + .map(|value| { + format!( + " Stage5InstructionReadRafPointValuePlan {{ symbol: {}, kind: {} }},", + rust_str(&value.symbol), + point_value_kind_expr(&value.kind), + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES: &[Stage5InstructionReadRafPointValuePlan] = &[\n{values}\n];\n\n" + ) +} + +fn point_value_kind_expr(kind: &Stage5InstructionReadRafPointValueKind) -> String { + match kind { + Stage5InstructionReadRafPointValueKind::LookupTable { index } => { + format!("Stage5InstructionReadRafPointValueKind::LookupTable {{ index: {index} }}") + } + Stage5InstructionReadRafPointValueKind::LeftOperand => { + "Stage5InstructionReadRafPointValueKind::LeftOperand".to_owned() + } + Stage5InstructionReadRafPointValueKind::RightOperand => { + "Stage5InstructionReadRafPointValueKind::RightOperand".to_owned() + } + Stage5InstructionReadRafPointValueKind::Identity => { + "Stage5InstructionReadRafPointValueKind::Identity".to_owned() + } + } +} + fn rust_str(value: &str) -> String { format!("{value:?}") } diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 9836cc4eaa..48df0316fc 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -95,9 +95,24 @@ pub struct Stage5InstructionReadRafPlan { pub instruction_ra_evals: &'static NamedEvalFamilyPlan, pub raf_flag_eval: &'static str, pub gamma: &'static str, + pub point_values: &'static [Stage5InstructionReadRafPointValuePlan], pub log_k: usize, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage5InstructionReadRafPointValuePlan { + pub symbol: &'static str, + pub kind: Stage5InstructionReadRafPointValueKind, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage5InstructionReadRafPointValueKind { + LookupTable { index: usize }, + LeftOperand, + RightOperand, + Identity, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage67BytecodeReadRafPlan { pub point: &'static str, @@ -205,31 +220,38 @@ pub fn evaluate_stage5_instruction_read_raf( evals: &[StageNamedEval], local_point: &[Fr], ) -> Result { - const XLEN: usize = 64; - - if local_point.len() < plan.log_k { - return Err(RuntimePlanError::InvalidInputLength { - input: plan.point, - expected: plan.log_k, - actual: local_point.len(), - }); - } - - let (r_address_prime, r_cycle) = local_point.split_at(plan.log_k); + let mut local_store = store.clone(); + evaluate_stage5_instruction_read_raf_point_values(plan, &mut local_store, local_point)?; + let (_, r_cycle) = instruction_read_raf_point_parts(plan, local_point)?; let r_cycle_prime = reverse_slice(r_cycle); let r_reduction = store_point(store, plan.lookup_output_point)?; let eq_eval_r_reduction = EqPolynomial::::mle(r_reduction, &r_cycle_prime); - let left_operand_eval = operand_polynomial_eval(r_address_prime, true); - let right_operand_eval = operand_polynomial_eval(r_address_prime, false); - let identity_poly_eval = identity_polynomial_eval(r_address_prime); + let left_operand_eval = instruction_read_raf_point_value( + plan, + &local_store, + Stage5InstructionReadRafPointValueKind::LeftOperand, + )?; + let right_operand_eval = instruction_read_raf_point_value( + plan, + &local_store, + Stage5InstructionReadRafPointValueKind::RightOperand, + )?; + let identity_poly_eval = instruction_read_raf_point_value( + plan, + &local_store, + Stage5InstructionReadRafPointValueKind::Identity, + )?; let table_flag_claims = eval_family_values(evals, plan.table_flag_evals)?; - let table_values = LookupTableKind::::all() - .iter() - .take(table_flag_claims.len()) - .map(|table| table.evaluate_mle::(r_address_prime)) - .collect::>(); + let table_values = instruction_read_raf_lookup_table_values(plan, &local_store)?; + if table_values.len() != table_flag_claims.len() { + return Err(RuntimePlanError::InvalidInputLength { + input: plan.table_flag_evals.symbol, + expected: table_flag_claims.len(), + actual: table_values.len(), + }); + } let val_claim = table_values .into_iter() .zip(table_flag_claims) @@ -248,6 +270,94 @@ pub fn evaluate_stage5_instruction_read_raf( Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim)) } +pub fn evaluate_stage5_instruction_read_raf_point_values( + plan: &Stage5InstructionReadRafPlan, + store: &mut ValueStore, + local_point: &[Fr], +) -> Result<(), RuntimePlanError> { + let (r_address_prime, _) = instruction_read_raf_point_parts(plan, local_point)?; + for value in plan.point_values { + let scalar = evaluate_stage5_instruction_read_raf_point_value(value.kind, r_address_prime)?; + store.insert_scalar(value.symbol, scalar); + } + Ok(()) +} + +fn evaluate_stage5_instruction_read_raf_point_value( + kind: Stage5InstructionReadRafPointValueKind, + r_address_prime: &[Fr], +) -> Result { + const XLEN: usize = 64; + Ok(match kind { + Stage5InstructionReadRafPointValueKind::LookupTable { index } => { + let tables = LookupTableKind::::all(); + let table = tables + .get(index) + .ok_or(RuntimePlanError::InvalidInputLength { + input: "stage5.instruction_read_raf.lookup_table", + expected: tables.len(), + actual: index + 1, + })?; + table.evaluate_mle::(r_address_prime) + } + Stage5InstructionReadRafPointValueKind::LeftOperand => { + operand_polynomial_eval(r_address_prime, true) + } + Stage5InstructionReadRafPointValueKind::RightOperand => { + operand_polynomial_eval(r_address_prime, false) + } + Stage5InstructionReadRafPointValueKind::Identity => identity_polynomial_eval(r_address_prime), + }) +} + +fn instruction_read_raf_point_value( + plan: &Stage5InstructionReadRafPlan, + store: &ValueStore, + kind: Stage5InstructionReadRafPointValueKind, +) -> Result { + let value = plan + .point_values + .iter() + .find(|value| value.kind == kind) + .ok_or(RuntimePlanError::MissingValue { symbol: plan.point })?; + store_scalar(store, value.symbol) +} + +fn instruction_read_raf_lookup_table_values( + plan: &Stage5InstructionReadRafPlan, + store: &ValueStore, +) -> Result, RuntimePlanError> { + let mut values = plan + .point_values + .iter() + .filter_map(|value| match value.kind { + Stage5InstructionReadRafPointValueKind::LookupTable { index } => { + Some((index, value.symbol)) + } + _ => None, + }) + .collect::>(); + values.sort_by_key(|(index, _)| *index); + values + .into_iter() + .map(|(_, symbol)| store_scalar(store, symbol)) + .collect() +} + +fn instruction_read_raf_point_parts<'a>( + plan: &Stage5InstructionReadRafPlan, + local_point: &'a [Fr], +) -> Result<(&'a [Fr], &'a [Fr]), RuntimePlanError> { + if local_point.len() < plan.log_k { + return Err(RuntimePlanError::InvalidInputLength { + input: plan.point, + expected: plan.log_k, + actual: local_point.len(), + }); + } + Ok(local_point.split_at(plan.log_k)) +} + pub fn stage67_trace_rounds( instance_results: &[SumcheckInstanceResultPlan], symbols: &Stage67RelationSymbols, diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 9836cc4eaa..48df0316fc 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -95,9 +95,24 @@ pub struct Stage5InstructionReadRafPlan { pub instruction_ra_evals: &'static NamedEvalFamilyPlan, pub raf_flag_eval: &'static str, pub gamma: &'static str, + pub point_values: &'static [Stage5InstructionReadRafPointValuePlan], pub log_k: usize, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage5InstructionReadRafPointValuePlan { + pub symbol: &'static str, + pub kind: Stage5InstructionReadRafPointValueKind, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Stage5InstructionReadRafPointValueKind { + LookupTable { index: usize }, + LeftOperand, + RightOperand, + Identity, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage67BytecodeReadRafPlan { pub point: &'static str, @@ -205,31 +220,38 @@ pub fn evaluate_stage5_instruction_read_raf( evals: &[StageNamedEval], local_point: &[Fr], ) -> Result { - const XLEN: usize = 64; - - if local_point.len() < plan.log_k { - return Err(RuntimePlanError::InvalidInputLength { - input: plan.point, - expected: plan.log_k, - actual: local_point.len(), - }); - } - - let (r_address_prime, r_cycle) = local_point.split_at(plan.log_k); + let mut local_store = store.clone(); + evaluate_stage5_instruction_read_raf_point_values(plan, &mut local_store, local_point)?; + let (_, r_cycle) = instruction_read_raf_point_parts(plan, local_point)?; let r_cycle_prime = reverse_slice(r_cycle); let r_reduction = store_point(store, plan.lookup_output_point)?; let eq_eval_r_reduction = EqPolynomial::::mle(r_reduction, &r_cycle_prime); - let left_operand_eval = operand_polynomial_eval(r_address_prime, true); - let right_operand_eval = operand_polynomial_eval(r_address_prime, false); - let identity_poly_eval = identity_polynomial_eval(r_address_prime); + let left_operand_eval = instruction_read_raf_point_value( + plan, + &local_store, + Stage5InstructionReadRafPointValueKind::LeftOperand, + )?; + let right_operand_eval = instruction_read_raf_point_value( + plan, + &local_store, + Stage5InstructionReadRafPointValueKind::RightOperand, + )?; + let identity_poly_eval = instruction_read_raf_point_value( + plan, + &local_store, + Stage5InstructionReadRafPointValueKind::Identity, + )?; let table_flag_claims = eval_family_values(evals, plan.table_flag_evals)?; - let table_values = LookupTableKind::::all() - .iter() - .take(table_flag_claims.len()) - .map(|table| table.evaluate_mle::(r_address_prime)) - .collect::>(); + let table_values = instruction_read_raf_lookup_table_values(plan, &local_store)?; + if table_values.len() != table_flag_claims.len() { + return Err(RuntimePlanError::InvalidInputLength { + input: plan.table_flag_evals.symbol, + expected: table_flag_claims.len(), + actual: table_values.len(), + }); + } let val_claim = table_values .into_iter() .zip(table_flag_claims) @@ -248,6 +270,94 @@ pub fn evaluate_stage5_instruction_read_raf( Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim)) } +pub fn evaluate_stage5_instruction_read_raf_point_values( + plan: &Stage5InstructionReadRafPlan, + store: &mut ValueStore, + local_point: &[Fr], +) -> Result<(), RuntimePlanError> { + let (r_address_prime, _) = instruction_read_raf_point_parts(plan, local_point)?; + for value in plan.point_values { + let scalar = evaluate_stage5_instruction_read_raf_point_value(value.kind, r_address_prime)?; + store.insert_scalar(value.symbol, scalar); + } + Ok(()) +} + +fn evaluate_stage5_instruction_read_raf_point_value( + kind: Stage5InstructionReadRafPointValueKind, + r_address_prime: &[Fr], +) -> Result { + const XLEN: usize = 64; + Ok(match kind { + Stage5InstructionReadRafPointValueKind::LookupTable { index } => { + let tables = LookupTableKind::::all(); + let table = tables + .get(index) + .ok_or(RuntimePlanError::InvalidInputLength { + input: "stage5.instruction_read_raf.lookup_table", + expected: tables.len(), + actual: index + 1, + })?; + table.evaluate_mle::(r_address_prime) + } + Stage5InstructionReadRafPointValueKind::LeftOperand => { + operand_polynomial_eval(r_address_prime, true) + } + Stage5InstructionReadRafPointValueKind::RightOperand => { + operand_polynomial_eval(r_address_prime, false) + } + Stage5InstructionReadRafPointValueKind::Identity => identity_polynomial_eval(r_address_prime), + }) +} + +fn instruction_read_raf_point_value( + plan: &Stage5InstructionReadRafPlan, + store: &ValueStore, + kind: Stage5InstructionReadRafPointValueKind, +) -> Result { + let value = plan + .point_values + .iter() + .find(|value| value.kind == kind) + .ok_or(RuntimePlanError::MissingValue { symbol: plan.point })?; + store_scalar(store, value.symbol) +} + +fn instruction_read_raf_lookup_table_values( + plan: &Stage5InstructionReadRafPlan, + store: &ValueStore, +) -> Result, RuntimePlanError> { + let mut values = plan + .point_values + .iter() + .filter_map(|value| match value.kind { + Stage5InstructionReadRafPointValueKind::LookupTable { index } => { + Some((index, value.symbol)) + } + _ => None, + }) + .collect::>(); + values.sort_by_key(|(index, _)| *index); + values + .into_iter() + .map(|(_, symbol)| store_scalar(store, symbol)) + .collect() +} + +fn instruction_read_raf_point_parts<'a>( + plan: &Stage5InstructionReadRafPlan, + local_point: &'a [Fr], +) -> Result<(&'a [Fr], &'a [Fr]), RuntimePlanError> { + if local_point.len() < plan.log_k { + return Err(RuntimePlanError::InvalidInputLength { + input: plan.point, + expected: plan.log_k, + actual: local_point.len(), + }); + } + Ok(local_point.split_at(plan.log_k)) +} + pub fn stage67_trace_rounds( instance_results: &[SumcheckInstanceResultPlan], symbols: &Stage67RelationSymbols, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 69ad0fde44..6aa7e65c1d 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{batch_claims, find_batch, find_plan, NamedEvalFamilyPlan}; -use super::jolt_relations::{evaluate_stage5_instruction_read_raf, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan}; +use super::jolt_relations::{evaluate_stage5_instruction_read_raf, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -200,6 +200,53 @@ pub const STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS: NamedEvalFamilyPlan = Na pub const STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES: &[&str] = &["stage5.instruction_read_raf.eval.InstructionRa_0", "stage5.instruction_read_raf.eval.InstructionRa_1", "stage5.instruction_read_raf.eval.InstructionRa_2", "stage5.instruction_read_raf.eval.InstructionRa_3", "stage5.instruction_read_raf.eval.InstructionRa_4", "stage5.instruction_read_raf.eval.InstructionRa_5", "stage5.instruction_read_raf.eval.InstructionRa_6", "stage5.instruction_read_raf.eval.InstructionRa_7"]; pub const STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS: NamedEvalFamilyPlan = NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.InstructionRa", evals: STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES }; +pub const STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES: &[Stage5InstructionReadRafPointValuePlan] = &[ + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_0", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 0 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_1", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 1 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_2", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 2 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_3", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 3 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_4", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 4 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_5", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 5 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_6", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 6 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_7", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 7 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_8", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 8 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_9", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 9 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_10", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 10 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_11", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 11 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_12", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 12 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_13", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 13 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_14", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 14 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_15", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 15 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_16", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 16 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_17", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 17 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_18", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 18 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_19", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 19 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_20", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 20 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_21", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 21 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_22", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 22 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_23", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 23 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_24", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 24 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_25", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 25 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_26", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 26 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_27", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 27 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_28", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 28 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_29", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 29 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_30", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 30 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_31", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 31 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_32", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 32 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_33", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 33 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_34", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 34 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_35", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 35 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_36", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 36 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_37", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 37 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_38", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 38 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_39", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 39 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_40", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 40 } }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LeftLookupOperand", kind: Stage5InstructionReadRafPointValueKind::LeftOperand }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.RightLookupOperand", kind: Stage5InstructionReadRafPointValueKind::RightOperand }, + Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.Identity", kind: Stage5InstructionReadRafPointValueKind::Identity }, +]; + pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan { point: "stage5.instruction_read_raf.point", lookup_output_point: "stage5.input.stage2.instruction.LookupOutput", @@ -207,6 +254,7 @@ pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage instruction_ra_evals: &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS, raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag", gamma: "stage5.instruction_read_raf.gamma", + point_values: STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES, log_k: 128, }; From 237c64fab3ca7bcbd4a9453eb2c2a184b5b80878 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 02:15:50 -0600 Subject: [PATCH 072/171] refactor(bolt): route stage5 read raf output claim --- .../src/protocols/jolt/emit/rust/stage5.rs | 235 ++++++++++++++++-- .../jolt/stage5_instruction_read_raf_plan.rs | 9 + .../jolt/verifier_jolt_relations.rs.template | 95 +------ .../protocols/jolt/verifier_output_claims.rs | 1 + crates/bolt/tests/commitment_ir.rs | 12 +- .../src/stages/jolt_relations.rs | 95 +------ crates/jolt-verifier/src/stages/stage5.rs | 172 ++++++++++++- 7 files changed, 409 insertions(+), 210 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 5463d7423e..4c7a98a369 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -15,13 +15,15 @@ use crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionR use crate::protocols::jolt::verifier_output_claims::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, - StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, + StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, StructuredPolynomialKind, + StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, - SumcheckOutputClaimAst as Stage5SumcheckOutputClaimAst, + StructuredPolynomialPointSegment, SumcheckOutputClaimAst as Stage5SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage5SumcheckOutputClaimPlan, SumcheckOutputEvalFamilyPlan as Stage5SumcheckOutputEvalFamilyPlan, SumcheckOutputFunctionFamilyPlan as Stage5SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan as Stage5SumcheckOutputProductFamilyPlan, + SumcheckOutputProductFamilyTermPlan as Stage5SumcheckOutputProductFamilyTermPlan, }; use crate::schema::verify_cpu_schema; @@ -195,6 +197,161 @@ pub struct Stage5SumcheckEvalPlan { pub oracle: String, } +fn append_instruction_read_raf_output_claim( + field_exprs: &mut Vec, + output_claims: &mut Vec, + plan: &Stage5InstructionReadRafEmitPlan, +) { + const PREFIX: &str = "stage5.instruction_read_raf.output"; + + let lookup_table_terms = plan + .table_flag_evals + .evals + .iter() + .zip( + plan.point_values + .iter() + .filter(|value| value.is_lookup_table()), + ) + .map( + |(flag_eval, table_value)| Stage5SumcheckOutputProductFamilyTermPlan { + gamma_power_offset: 0, + evals: vec![table_value.symbol.clone(), flag_eval.clone()], + factors: Vec::new(), + }, + ) + .collect::>(); + let table_value_family = Stage5SumcheckOutputProductFamilyPlan { + symbol: format!("{PREFIX}.product.LookupTableValues"), + gamma: None, + terms: lookup_table_terms, + }; + let ra_product_family = Stage5SumcheckOutputProductFamilyPlan { + symbol: format!("{PREFIX}.product.InstructionRa"), + gamma: None, + terms: vec![Stage5SumcheckOutputProductFamilyTermPlan { + gamma_power_offset: 0, + evals: plan.instruction_ra_evals.evals.clone(), + factors: Vec::new(), + }], + }; + let eq = Stage5StructuredPolynomialEvalPlan { + symbol: format!("{PREFIX}.eq.LookupOutputCycle"), + polynomial: StructuredPolynomialKind::Eq, + x_point: Stage5StructuredPolynomialPointPlan { + source: plan.point.clone(), + segment: StructuredPolynomialPointSegment::Suffix, + length: StructuredPolynomialPointLength::YPoint, + order: StructuredPolynomialPointOrder::Reverse, + }, + y_point: Stage5StructuredPolynomialPointPlan { + source: plan.lookup_output_point.clone(), + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + }; + + let left = "stage5.instruction_read_raf.point_value.LeftLookupOperand"; + let right = "stage5.instruction_read_raf.point_value.RightLookupOperand"; + let identity = "stage5.instruction_read_raf.point_value.Identity"; + let table_values = table_value_family.symbol.clone(); + let ra_product = ra_product_family.symbol.clone(); + let eq_symbol = eq.symbol.clone(); + + field_exprs.extend([ + stage5_output_field_expr( + &format!("{PREFIX}.term.GammaRightLookupOperand"), + "field.mul", + &[&plan.gamma, right], + ), + stage5_output_field_expr( + &format!("{PREFIX}.partial.LeftPlusGammaRight"), + "field.add", + &[left, &format!("{PREFIX}.term.GammaRightLookupOperand")], + ), + stage5_output_field_expr( + &format!("{PREFIX}.term.RafFlagLeftPlusGammaRight"), + "field.mul", + &[ + &plan.raf_flag_eval, + &format!("{PREFIX}.partial.LeftPlusGammaRight"), + ], + ), + stage5_output_field_expr( + &format!("{PREFIX}.partial.NonRafLookupOperands"), + "field.sub", + &[ + &format!("{PREFIX}.partial.LeftPlusGammaRight"), + &format!("{PREFIX}.term.RafFlagLeftPlusGammaRight"), + ], + ), + stage5_output_field_expr( + &format!("{PREFIX}.term.GammaIdentity"), + "field.mul", + &[&plan.gamma, identity], + ), + stage5_output_field_expr( + &format!("{PREFIX}.term.RafFlagGammaIdentity"), + "field.mul", + &[&plan.raf_flag_eval, &format!("{PREFIX}.term.GammaIdentity")], + ), + stage5_output_field_expr( + &format!("{PREFIX}.partial.RafClaim"), + "field.add", + &[ + &format!("{PREFIX}.partial.NonRafLookupOperands"), + &format!("{PREFIX}.term.RafFlagGammaIdentity"), + ], + ), + stage5_output_field_expr( + &format!("{PREFIX}.term.GammaRafClaim"), + "field.mul", + &[&plan.gamma, &format!("{PREFIX}.partial.RafClaim")], + ), + stage5_output_field_expr( + &format!("{PREFIX}.partial.LookupOrRaf"), + "field.add", + &[&table_values, &format!("{PREFIX}.term.GammaRafClaim")], + ), + stage5_output_field_expr( + &format!("{PREFIX}.partial.EqRa"), + "field.mul", + &[&eq_symbol, &ra_product], + ), + stage5_output_field_expr( + &format!("{PREFIX}.claim_expr"), + "field.mul", + &[ + &format!("{PREFIX}.partial.EqRa"), + &format!("{PREFIX}.partial.LookupOrRaf"), + ], + ), + ]); + output_claims.push(Stage5SumcheckOutputClaimPlan { + relation: "jolt.stage5.instruction_read_raf".to_owned(), + polynomial_evals: vec![eq], + eval_families: Vec::new(), + product_families: vec![table_value_family, ra_product_family], + function_families: Vec::new(), + claim_value: format!("{PREFIX}.claim_expr"), + }); +} + +fn stage5_output_field_expr(symbol: &str, formula: &str, operands: &[&str]) -> Stage5FieldExprPlan { + let operands = operands + .iter() + .map(|operand| (*operand).to_owned()) + .collect::>(); + Stage5FieldExprPlan { + symbol: symbol.to_owned(), + kind: "op".to_owned(), + formula: formula.to_owned(), + operand_names: operands.clone(), + operands, + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5PointSlicePlan { pub symbol: String, @@ -590,7 +747,16 @@ impl Stage5CpuProgram { .map(|claim| claim.claim_value.as_str()), ); } - let output_claims = if role == Role::Verifier { + let instruction_read_raf_plan = if role == Role::Verifier { + Some(Stage5InstructionReadRafEmitPlan::from_evals( + evals + .iter() + .map(|eval| (eval.oracle.as_str(), eval.name.as_str())), + )?) + } else { + None + }; + let mut output_claims = if role == Role::Verifier { verifier_output_claims::resolve_output_claims( "stage5", &output_values, @@ -603,15 +769,9 @@ impl Stage5CpuProgram { } else { Vec::new() }; - let instruction_read_raf_plan = if role == Role::Verifier { - Some(Stage5InstructionReadRafEmitPlan::from_evals( - evals - .iter() - .map(|eval| (eval.oracle.as_str(), eval.name.as_str())), - )?) - } else { - None - }; + if let Some(plan) = &instruction_read_raf_plan { + append_instruction_read_raf_output_claim(&mut field_exprs, &mut output_claims, plan); + } Ok(Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, @@ -744,6 +904,12 @@ impl Stage5CpuProgram { self.output_values.iter().map(|value| &value.symbol), verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), + verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + ); values.extend( self.output_families.iter().map(|family| &family.symbol), verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, @@ -760,10 +926,34 @@ impl Stage5CpuProgram { .map(|family| &family.symbol), verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), + verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, + ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), + verifier_output_claims::VerifierScalarSourceKind::OutputProductFamily, + ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), + verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, + ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), verifier_output_claims::VerifierScalarSourceKind::FieldExpr, ); + if let Some(plan) = &self.instruction_read_raf_plan { + values.extend( + plan.point_values.iter().map(|value| &value.symbol), + verifier_output_claims::VerifierScalarSourceKind::PointDerived, + ); + } values.extend( self.evals.iter().map(|eval| &eval.symbol), verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, @@ -1155,7 +1345,7 @@ impl Stage5CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan, NamedEvalFamilyPlan};\n\ - use super::jolt_relations::{evaluate_stage5_instruction_read_raf, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan};\n\ + use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_values, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -2422,9 +2612,24 @@ fn expected_batched_output_claim( }; let value = match relation { Stage5RelationKind::Stage5InstructionReadRaf => { - evaluate_stage5_instruction_read_raf( + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage5Error::UnsupportedRelation { + relation: instance.relation, + })?; + let mut local_store = store.clone(); + evaluate_stage5_instruction_read_raf_point_values( &STAGE5_INSTRUCTION_READ_RAF_PLAN, - store, + &mut local_store, + local_point, + )?; + bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + &local_store, + instance.symbol, evals, local_point, )? diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 2cd28a5c61..38918299ab 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -106,6 +106,15 @@ pub(crate) struct Stage5InstructionReadRafPointValueEmitPlan { pub(crate) kind: Stage5InstructionReadRafPointValueKind, } +impl Stage5InstructionReadRafPointValueEmitPlan { + pub(crate) fn is_lookup_table(&self) -> bool { + matches!( + self.kind, + Stage5InstructionReadRafPointValueKind::LookupTable { .. } + ) + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) enum Stage5InstructionReadRafPointValueKind { LookupTable { index: usize }, diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 48df0316fc..cce7fd7394 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -29,9 +29,8 @@ use jolt_lookup_tables::LookupTableKind; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - eval_by_name, eval_family_values, field_powers, prefix_point, reverse_slice, store_point, - store_scalar, suffix_point, NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, - SumcheckInstanceResultPlan, ValueStore, + eval_family_values, field_powers, prefix_point, store_point, store_scalar, suffix_point, + NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -214,62 +213,6 @@ pub trait Stage67BytecodeEntry { fn is_noop(&self) -> bool; } -pub fn evaluate_stage5_instruction_read_raf( - plan: &Stage5InstructionReadRafPlan, - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], -) -> Result { - let mut local_store = store.clone(); - evaluate_stage5_instruction_read_raf_point_values(plan, &mut local_store, local_point)?; - let (_, r_cycle) = instruction_read_raf_point_parts(plan, local_point)?; - let r_cycle_prime = reverse_slice(r_cycle); - let r_reduction = store_point(store, plan.lookup_output_point)?; - let eq_eval_r_reduction = EqPolynomial::::mle(r_reduction, &r_cycle_prime); - - let left_operand_eval = instruction_read_raf_point_value( - plan, - &local_store, - Stage5InstructionReadRafPointValueKind::LeftOperand, - )?; - let right_operand_eval = instruction_read_raf_point_value( - plan, - &local_store, - Stage5InstructionReadRafPointValueKind::RightOperand, - )?; - let identity_poly_eval = instruction_read_raf_point_value( - plan, - &local_store, - Stage5InstructionReadRafPointValueKind::Identity, - )?; - - let table_flag_claims = eval_family_values(evals, plan.table_flag_evals)?; - let table_values = instruction_read_raf_lookup_table_values(plan, &local_store)?; - if table_values.len() != table_flag_claims.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: plan.table_flag_evals.symbol, - expected: table_flag_claims.len(), - actual: table_values.len(), - }); - } - let val_claim = table_values - .into_iter() - .zip(table_flag_claims) - .map(|(table_value, flag_claim)| table_value * flag_claim) - .sum::(); - - let ra_claim = eval_family_values(evals, plan.instruction_ra_evals)? - .into_iter() - .product::(); - let raf_flag_claim = eval_by_name(evals, plan.raf_flag_eval)?; - let gamma = store_scalar(store, plan.gamma)?; - - let raf_claim = (Fr::from_u64(1) - raf_flag_claim) - * (left_operand_eval + gamma * right_operand_eval) - + raf_flag_claim * gamma * identity_poly_eval; - Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim)) -} - pub fn evaluate_stage5_instruction_read_raf_point_values( plan: &Stage5InstructionReadRafPlan, store: &mut ValueStore, @@ -310,40 +253,6 @@ fn evaluate_stage5_instruction_read_raf_point_value( }) } -fn instruction_read_raf_point_value( - plan: &Stage5InstructionReadRafPlan, - store: &ValueStore, - kind: Stage5InstructionReadRafPointValueKind, -) -> Result { - let value = plan - .point_values - .iter() - .find(|value| value.kind == kind) - .ok_or(RuntimePlanError::MissingValue { symbol: plan.point })?; - store_scalar(store, value.symbol) -} - -fn instruction_read_raf_lookup_table_values( - plan: &Stage5InstructionReadRafPlan, - store: &ValueStore, -) -> Result, RuntimePlanError> { - let mut values = plan - .point_values - .iter() - .filter_map(|value| match value.kind { - Stage5InstructionReadRafPointValueKind::LookupTable { index } => { - Some((index, value.symbol)) - } - _ => None, - }) - .collect::>(); - values.sort_by_key(|(index, _)| *index); - values - .into_iter() - .map(|(_, symbol)| store_scalar(store, symbol)) - .collect() -} - fn instruction_read_raf_point_parts<'a>( plan: &Stage5InstructionReadRafPlan, local_point: &'a [Fr], diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index 14905e2a83..710c0f171a 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -480,6 +480,7 @@ pub enum VerifierScalarSourceKind { FieldConstant, TranscriptScalar, FieldExpr, + PointDerived, SumcheckEval, StructuredPolynomialEval, OutputEvalFamily, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 8795cd9c40..c029212b7d 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1389,7 +1389,7 @@ fn stage5_rust_targets_extract_and_compile() { assert_eq!(prover_program.output_values.len(), 4); assert!(prover_program.output_claims.is_empty()); assert_eq!(verifier_program.output_values.len(), 4); - assert_eq!(verifier_program.output_claims.len(), 2); + assert_eq!(verifier_program.output_claims.len(), 3); assert_eq!( prover_program.point_slices.len(), params.instruction_ra_virtual_d + 3 @@ -1438,16 +1438,13 @@ fn stage5_rust_targets_extract_and_compile() { .contains("relation: Some(Stage5RelationKind::Stage5Batched)")); assert!(verifier_source .source - .contains("expected_instruction_read_raf")); + .contains("evaluate_stage5_instruction_read_raf_point_values")); assert!(verifier_source .source .contains("Stage5RelationKind::Stage5InstructionReadRaf")); assert!(verifier_source .source - .contains("LookupTableKind::::all")); - assert!(verifier_source - .source - .contains("use jolt_lookup_tables::LookupTableKind")); + .contains("Stage5InstructionReadRafPointValueKind::LookupTable")); assert!(!verifier_source .source .contains("expected_ram_ra_claim_reduction")); @@ -1457,6 +1454,9 @@ fn stage5_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("Stage5SumcheckOutputClaimPlan")); + assert!(verifier_source + .source + .contains("stage5.instruction_read_raf.output.claim_expr")); assert!(verifier_source .source .contains("stage5.ram_ra_claim_reduction.output.eq.ReadWrite")); diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 48df0316fc..cce7fd7394 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -29,9 +29,8 @@ use jolt_lookup_tables::LookupTableKind; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - eval_by_name, eval_family_values, field_powers, prefix_point, reverse_slice, store_point, - store_scalar, suffix_point, NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, - SumcheckInstanceResultPlan, ValueStore, + eval_family_values, field_powers, prefix_point, store_point, store_scalar, suffix_point, + NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -214,62 +213,6 @@ pub trait Stage67BytecodeEntry { fn is_noop(&self) -> bool; } -pub fn evaluate_stage5_instruction_read_raf( - plan: &Stage5InstructionReadRafPlan, - store: &ValueStore, - evals: &[StageNamedEval], - local_point: &[Fr], -) -> Result { - let mut local_store = store.clone(); - evaluate_stage5_instruction_read_raf_point_values(plan, &mut local_store, local_point)?; - let (_, r_cycle) = instruction_read_raf_point_parts(plan, local_point)?; - let r_cycle_prime = reverse_slice(r_cycle); - let r_reduction = store_point(store, plan.lookup_output_point)?; - let eq_eval_r_reduction = EqPolynomial::::mle(r_reduction, &r_cycle_prime); - - let left_operand_eval = instruction_read_raf_point_value( - plan, - &local_store, - Stage5InstructionReadRafPointValueKind::LeftOperand, - )?; - let right_operand_eval = instruction_read_raf_point_value( - plan, - &local_store, - Stage5InstructionReadRafPointValueKind::RightOperand, - )?; - let identity_poly_eval = instruction_read_raf_point_value( - plan, - &local_store, - Stage5InstructionReadRafPointValueKind::Identity, - )?; - - let table_flag_claims = eval_family_values(evals, plan.table_flag_evals)?; - let table_values = instruction_read_raf_lookup_table_values(plan, &local_store)?; - if table_values.len() != table_flag_claims.len() { - return Err(RuntimePlanError::InvalidInputLength { - input: plan.table_flag_evals.symbol, - expected: table_flag_claims.len(), - actual: table_values.len(), - }); - } - let val_claim = table_values - .into_iter() - .zip(table_flag_claims) - .map(|(table_value, flag_claim)| table_value * flag_claim) - .sum::(); - - let ra_claim = eval_family_values(evals, plan.instruction_ra_evals)? - .into_iter() - .product::(); - let raf_flag_claim = eval_by_name(evals, plan.raf_flag_eval)?; - let gamma = store_scalar(store, plan.gamma)?; - - let raf_claim = (Fr::from_u64(1) - raf_flag_claim) - * (left_operand_eval + gamma * right_operand_eval) - + raf_flag_claim * gamma * identity_poly_eval; - Ok(eq_eval_r_reduction * ra_claim * (val_claim + gamma * raf_claim)) -} - pub fn evaluate_stage5_instruction_read_raf_point_values( plan: &Stage5InstructionReadRafPlan, store: &mut ValueStore, @@ -310,40 +253,6 @@ fn evaluate_stage5_instruction_read_raf_point_value( }) } -fn instruction_read_raf_point_value( - plan: &Stage5InstructionReadRafPlan, - store: &ValueStore, - kind: Stage5InstructionReadRafPointValueKind, -) -> Result { - let value = plan - .point_values - .iter() - .find(|value| value.kind == kind) - .ok_or(RuntimePlanError::MissingValue { symbol: plan.point })?; - store_scalar(store, value.symbol) -} - -fn instruction_read_raf_lookup_table_values( - plan: &Stage5InstructionReadRafPlan, - store: &ValueStore, -) -> Result, RuntimePlanError> { - let mut values = plan - .point_values - .iter() - .filter_map(|value| match value.kind { - Stage5InstructionReadRafPointValueKind::LookupTable { index } => { - Some((index, value.symbol)) - } - _ => None, - }) - .collect::>(); - values.sort_by_key(|(index, _)| *index); - values - .into_iter() - .map(|(_, symbol)| store_scalar(store, symbol)) - .collect() -} - fn instruction_read_raf_point_parts<'a>( plan: &Stage5InstructionReadRafPlan, local_point: &'a [Fr], diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 6aa7e65c1d..d56d8bdbb5 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{batch_claims, find_batch, find_plan, NamedEvalFamilyPlan}; -use super::jolt_relations::{evaluate_stage5_instruction_read_raf, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan}; +use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_values, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -110,6 +110,17 @@ pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[ Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.output.eq_combined", "stage5.ram_ra_claim_reduction.eval.RamRa"] }, Stage5FieldExprPlan { symbol: "stage5.registers_val_evaluation.output.product.RdIncRdWa", kind: Stage5FieldExprKind::Mul, operands: &["stage5.registers_val_evaluation.eval.RdInc", "stage5.registers_val_evaluation.eval.RdWa"] }, Stage5FieldExprPlan { symbol: "stage5.registers_val_evaluation.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.registers_val_evaluation.output.product.RdIncRdWa", "stage5.registers_val_evaluation.output.lt.RegistersValCycle"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaRightLookupOperand", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.point_value.RightLookupOperand"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.output.term.GammaRightLookupOperand"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.RafFlagLeftPlusGammaRight", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.eval.InstructionRafFlag", "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.NonRafLookupOperands", kind: Stage5FieldExprKind::Sub, operands: &["stage5.instruction_read_raf.output.partial.LeftPlusGammaRight", "stage5.instruction_read_raf.output.term.RafFlagLeftPlusGammaRight"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaIdentity", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.point_value.Identity"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.RafFlagGammaIdentity", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.eval.InstructionRafFlag", "stage5.instruction_read_raf.output.term.GammaIdentity"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.RafClaim", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.output.partial.NonRafLookupOperands", "stage5.instruction_read_raf.output.term.RafFlagGammaIdentity"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaRafClaim", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.output.partial.RafClaim"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.LookupOrRaf", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.output.product.LookupTableValues", "stage5.instruction_read_raf.output.term.GammaRafClaim"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.EqRa", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.output.eq.LookupOutputCycle", "stage5.instruction_read_raf.output.product.InstructionRa"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.output.partial.EqRa", "stage5.instruction_read_raf.output.partial.LookupOrRaf"] }, ]; pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[ @@ -357,9 +368,149 @@ pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage5StructuredPolynomialEva Stage5StructuredPolynomialEvalPlan { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", polynomial: Stage5StructuredPolynomialKind::Lt, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.registers_val_evaluation.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage4.registers.RegistersVal", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, ]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ + Stage5StructuredPolynomialEvalPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.instruction_read_raf.point", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::YPoint, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.instruction.LookupOutput", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::AsIs } }, +]; + +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_8_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_8_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_9_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_9_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_10_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_10_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_11_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_11_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_12_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_12_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_13_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_13_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_14_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_14_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_15_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_15_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_16_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_16_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_17_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_17_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_18_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_18_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_19_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_19_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_20_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_20_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_21_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_21_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_22_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_22_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_23_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_23_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_24_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_24_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_25_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_25_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_26_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_26_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_27_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_27_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_28_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_28_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_29_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_29_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_30_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_30_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_31_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_31_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_32_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_32_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_33_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_33_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_34_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_34_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_35_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_35_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_36_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_36_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_37_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_37_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_38_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_38_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_39_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_39_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_40_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_40_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_8_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_8_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_9_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_9_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_10_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_10_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_11_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_11_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_12_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_12_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_13_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_13_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_14_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_14_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_15_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_15_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_16_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_16_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_17_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_17_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_18_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_18_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_19_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_19_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_20_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_20_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_21_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_21_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_22_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_22_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_23_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_23_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_24_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_24_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_25_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_25_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_26_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_26_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_27_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_27_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_28_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_28_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_29_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_29_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_30_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_30_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_31_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_31_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_32_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_32_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_33_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_33_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_34_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_34_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_35_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_35_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_36_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_36_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_37_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_37_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_38_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_38_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_39_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_39_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_40_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_40_FACTORS }, +]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_EVALS: &[&str] = &["stage5.instruction_read_raf.eval.InstructionRa_0", "stage5.instruction_read_raf.eval.InstructionRa_1", "stage5.instruction_read_raf.eval.InstructionRa_2", "stage5.instruction_read_raf.eval.InstructionRa_3", "stage5.instruction_read_raf.eval.InstructionRa_4", "stage5.instruction_read_raf.eval.InstructionRa_5", "stage5.instruction_read_raf.eval.InstructionRa_6", "stage5.instruction_read_raf.eval.InstructionRa_7"]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_FACTORS: &[&str] = &[]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_FACTORS }, +]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.LookupTableValues", gamma: None, terms: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", gamma: None, terms: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERMS }, +]; + pub const STAGE5_SUMCHECK_OUTPUT_CLAIMS: &[Stage5SumcheckOutputClaimPlan] = &[ Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage5.instruction_read_raf.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { @@ -647,9 +798,24 @@ fn expected_batched_output_claim( }; let value = match relation { Stage5RelationKind::Stage5InstructionReadRaf => { - evaluate_stage5_instruction_read_raf( + let output_claim = program + .output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(VerifyStage5Error::UnsupportedRelation { + relation: instance.relation, + })?; + let mut local_store = store.clone(); + evaluate_stage5_instruction_read_raf_point_values( &STAGE5_INSTRUCTION_READ_RAF_PLAN, - store, + &mut local_store, + local_point, + )?; + bolt_verifier_runtime::evaluate_sumcheck_output_claim( + output_claim, + program.field_exprs, + &local_store, + instance.symbol, evals, local_point, )? From 90e8fad1c294c3e3bd9224b4029c6c348a424883 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 02:22:18 -0600 Subject: [PATCH 073/171] refactor(bolt): isolate stage5 read raf planning --- .../src/protocols/jolt/emit/rust/stage5.rs | 169 +------------ .../jolt/stage5_instruction_read_raf_plan.rs | 222 ++++++++++++++++++ 2 files changed, 235 insertions(+), 156 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 4c7a98a369..7c7a475fa3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -11,19 +11,19 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionReadRafEmitPlan; +use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ + Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, +}; use crate::protocols::jolt::verifier_output_claims::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, - StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, StructuredPolynomialKind, - StructuredPolynomialPointLength, StructuredPolynomialPointOrder, + StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment, SumcheckOutputClaimAst as Stage5SumcheckOutputClaimAst, + SumcheckOutputClaimAst as Stage5SumcheckOutputClaimAst, SumcheckOutputClaimPlan as Stage5SumcheckOutputClaimPlan, SumcheckOutputEvalFamilyPlan as Stage5SumcheckOutputEvalFamilyPlan, SumcheckOutputFunctionFamilyPlan as Stage5SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan as Stage5SumcheckOutputProductFamilyPlan, - SumcheckOutputProductFamilyTermPlan as Stage5SumcheckOutputProductFamilyTermPlan, }; use crate::schema::verify_cpu_schema; @@ -197,158 +197,13 @@ pub struct Stage5SumcheckEvalPlan { pub oracle: String, } -fn append_instruction_read_raf_output_claim( - field_exprs: &mut Vec, - output_claims: &mut Vec, - plan: &Stage5InstructionReadRafEmitPlan, -) { - const PREFIX: &str = "stage5.instruction_read_raf.output"; - - let lookup_table_terms = plan - .table_flag_evals - .evals - .iter() - .zip( - plan.point_values - .iter() - .filter(|value| value.is_lookup_table()), - ) - .map( - |(flag_eval, table_value)| Stage5SumcheckOutputProductFamilyTermPlan { - gamma_power_offset: 0, - evals: vec![table_value.symbol.clone(), flag_eval.clone()], - factors: Vec::new(), - }, - ) - .collect::>(); - let table_value_family = Stage5SumcheckOutputProductFamilyPlan { - symbol: format!("{PREFIX}.product.LookupTableValues"), - gamma: None, - terms: lookup_table_terms, - }; - let ra_product_family = Stage5SumcheckOutputProductFamilyPlan { - symbol: format!("{PREFIX}.product.InstructionRa"), - gamma: None, - terms: vec![Stage5SumcheckOutputProductFamilyTermPlan { - gamma_power_offset: 0, - evals: plan.instruction_ra_evals.evals.clone(), - factors: Vec::new(), - }], - }; - let eq = Stage5StructuredPolynomialEvalPlan { - symbol: format!("{PREFIX}.eq.LookupOutputCycle"), - polynomial: StructuredPolynomialKind::Eq, - x_point: Stage5StructuredPolynomialPointPlan { - source: plan.point.clone(), - segment: StructuredPolynomialPointSegment::Suffix, - length: StructuredPolynomialPointLength::YPoint, - order: StructuredPolynomialPointOrder::Reverse, - }, - y_point: Stage5StructuredPolynomialPointPlan { - source: plan.lookup_output_point.clone(), - segment: StructuredPolynomialPointSegment::Full, - length: StructuredPolynomialPointLength::Full, - order: StructuredPolynomialPointOrder::AsIs, - }, - }; - - let left = "stage5.instruction_read_raf.point_value.LeftLookupOperand"; - let right = "stage5.instruction_read_raf.point_value.RightLookupOperand"; - let identity = "stage5.instruction_read_raf.point_value.Identity"; - let table_values = table_value_family.symbol.clone(); - let ra_product = ra_product_family.symbol.clone(); - let eq_symbol = eq.symbol.clone(); - - field_exprs.extend([ - stage5_output_field_expr( - &format!("{PREFIX}.term.GammaRightLookupOperand"), - "field.mul", - &[&plan.gamma, right], - ), - stage5_output_field_expr( - &format!("{PREFIX}.partial.LeftPlusGammaRight"), - "field.add", - &[left, &format!("{PREFIX}.term.GammaRightLookupOperand")], - ), - stage5_output_field_expr( - &format!("{PREFIX}.term.RafFlagLeftPlusGammaRight"), - "field.mul", - &[ - &plan.raf_flag_eval, - &format!("{PREFIX}.partial.LeftPlusGammaRight"), - ], - ), - stage5_output_field_expr( - &format!("{PREFIX}.partial.NonRafLookupOperands"), - "field.sub", - &[ - &format!("{PREFIX}.partial.LeftPlusGammaRight"), - &format!("{PREFIX}.term.RafFlagLeftPlusGammaRight"), - ], - ), - stage5_output_field_expr( - &format!("{PREFIX}.term.GammaIdentity"), - "field.mul", - &[&plan.gamma, identity], - ), - stage5_output_field_expr( - &format!("{PREFIX}.term.RafFlagGammaIdentity"), - "field.mul", - &[&plan.raf_flag_eval, &format!("{PREFIX}.term.GammaIdentity")], - ), - stage5_output_field_expr( - &format!("{PREFIX}.partial.RafClaim"), - "field.add", - &[ - &format!("{PREFIX}.partial.NonRafLookupOperands"), - &format!("{PREFIX}.term.RafFlagGammaIdentity"), - ], - ), - stage5_output_field_expr( - &format!("{PREFIX}.term.GammaRafClaim"), - "field.mul", - &[&plan.gamma, &format!("{PREFIX}.partial.RafClaim")], - ), - stage5_output_field_expr( - &format!("{PREFIX}.partial.LookupOrRaf"), - "field.add", - &[&table_values, &format!("{PREFIX}.term.GammaRafClaim")], - ), - stage5_output_field_expr( - &format!("{PREFIX}.partial.EqRa"), - "field.mul", - &[&eq_symbol, &ra_product], - ), - stage5_output_field_expr( - &format!("{PREFIX}.claim_expr"), - "field.mul", - &[ - &format!("{PREFIX}.partial.EqRa"), - &format!("{PREFIX}.partial.LookupOrRaf"), - ], - ), - ]); - output_claims.push(Stage5SumcheckOutputClaimPlan { - relation: "jolt.stage5.instruction_read_raf".to_owned(), - polynomial_evals: vec![eq], - eval_families: Vec::new(), - product_families: vec![table_value_family, ra_product_family], - function_families: Vec::new(), - claim_value: format!("{PREFIX}.claim_expr"), - }); -} - -fn stage5_output_field_expr(symbol: &str, formula: &str, operands: &[&str]) -> Stage5FieldExprPlan { - let operands = operands - .iter() - .map(|operand| (*operand).to_owned()) - .collect::>(); +fn stage5_field_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage5FieldExprPlan { Stage5FieldExprPlan { - symbol: symbol.to_owned(), + symbol: expr.symbol, kind: "op".to_owned(), - formula: formula.to_owned(), - operand_names: operands.clone(), - operands, + formula: expr.formula, + operand_names: expr.operands.clone(), + operands: expr.operands, } } @@ -770,7 +625,9 @@ impl Stage5CpuProgram { Vec::new() }; if let Some(plan) = &instruction_read_raf_plan { - append_instruction_read_raf_output_claim(&mut field_exprs, &mut output_claims, plan); + let output_plan = plan.output_claim_plan(); + field_exprs.extend(output_plan.field_exprs.into_iter().map(stage5_field_expr)); + output_claims.push(output_plan.claim); } Ok(Self { diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 38918299ab..07892a0b2f 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -1,4 +1,10 @@ use crate::emit::rust::{push_format, EmitError}; +use crate::protocols::jolt::verifier_output_claims::{ + StructuredPolynomialEvalPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, + StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment, SumcheckOutputClaimPlan, SumcheckOutputProductFamilyPlan, + SumcheckOutputProductFamilyTermPlan, +}; #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Stage5InstructionReadRafEmitPlan { @@ -98,6 +104,138 @@ impl Stage5InstructionReadRafEmitPlan { ); source } + + pub(crate) fn output_claim_plan(&self) -> Stage5InstructionReadRafOutputPlan { + const PREFIX: &str = "stage5.instruction_read_raf.output"; + + let table_value_family = SumcheckOutputProductFamilyPlan { + symbol: format!("{PREFIX}.product.LookupTableValues"), + gamma: None, + terms: self + .table_flag_evals + .evals + .iter() + .zip( + self.point_values + .iter() + .filter(|value| value.is_lookup_table()), + ) + .map( + |(flag_eval, table_value)| SumcheckOutputProductFamilyTermPlan { + gamma_power_offset: 0, + evals: vec![table_value.symbol.clone(), flag_eval.clone()], + factors: Vec::new(), + }, + ) + .collect(), + }; + let ra_product_family = SumcheckOutputProductFamilyPlan { + symbol: format!("{PREFIX}.product.InstructionRa"), + gamma: None, + terms: vec![SumcheckOutputProductFamilyTermPlan { + gamma_power_offset: 0, + evals: self.instruction_ra_evals.evals.clone(), + factors: Vec::new(), + }], + }; + let eq = StructuredPolynomialEvalPlan { + symbol: format!("{PREFIX}.eq.LookupOutputCycle"), + polynomial: StructuredPolynomialKind::Eq, + x_point: StructuredPolynomialPointPlan { + source: self.point.clone(), + segment: StructuredPolynomialPointSegment::Suffix, + length: StructuredPolynomialPointLength::YPoint, + order: StructuredPolynomialPointOrder::Reverse, + }, + y_point: StructuredPolynomialPointPlan { + source: self.lookup_output_point.clone(), + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + }; + + let left = "stage5.instruction_read_raf.point_value.LeftLookupOperand".to_owned(); + let right = "stage5.instruction_read_raf.point_value.RightLookupOperand".to_owned(); + let identity = "stage5.instruction_read_raf.point_value.Identity".to_owned(); + let gamma_right = format!("{PREFIX}.term.GammaRightLookupOperand"); + let left_plus_gamma_right = format!("{PREFIX}.partial.LeftPlusGammaRight"); + let raf_flag_left_plus_gamma_right = format!("{PREFIX}.term.RafFlagLeftPlusGammaRight"); + let non_raf_lookup_operands = format!("{PREFIX}.partial.NonRafLookupOperands"); + let gamma_identity = format!("{PREFIX}.term.GammaIdentity"); + let raf_flag_gamma_identity = format!("{PREFIX}.term.RafFlagGammaIdentity"); + let raf_claim = format!("{PREFIX}.partial.RafClaim"); + let gamma_raf_claim = format!("{PREFIX}.term.GammaRafClaim"); + let lookup_or_raf = format!("{PREFIX}.partial.LookupOrRaf"); + let eq_ra = format!("{PREFIX}.partial.EqRa"); + let claim_expr = format!("{PREFIX}.claim_expr"); + + let field_exprs = vec![ + output_field_expr( + gamma_right.clone(), + "field.mul", + vec![self.gamma.clone(), right], + ), + output_field_expr( + left_plus_gamma_right.clone(), + "field.add", + vec![left, gamma_right], + ), + output_field_expr( + raf_flag_left_plus_gamma_right.clone(), + "field.mul", + vec![self.raf_flag_eval.clone(), left_plus_gamma_right.clone()], + ), + output_field_expr( + non_raf_lookup_operands.clone(), + "field.sub", + vec![left_plus_gamma_right, raf_flag_left_plus_gamma_right], + ), + output_field_expr( + gamma_identity.clone(), + "field.mul", + vec![self.gamma.clone(), identity], + ), + output_field_expr( + raf_flag_gamma_identity.clone(), + "field.mul", + vec![self.raf_flag_eval.clone(), gamma_identity], + ), + output_field_expr( + raf_claim.clone(), + "field.add", + vec![non_raf_lookup_operands, raf_flag_gamma_identity], + ), + output_field_expr( + gamma_raf_claim.clone(), + "field.mul", + vec![self.gamma.clone(), raf_claim], + ), + output_field_expr( + lookup_or_raf.clone(), + "field.add", + vec![table_value_family.symbol.clone(), gamma_raf_claim], + ), + output_field_expr( + eq_ra.clone(), + "field.mul", + vec![eq.symbol.clone(), ra_product_family.symbol.clone()], + ), + output_field_expr(claim_expr.clone(), "field.mul", vec![eq_ra, lookup_or_raf]), + ]; + + Stage5InstructionReadRafOutputPlan { + field_exprs, + claim: SumcheckOutputClaimPlan { + relation: "jolt.stage5.instruction_read_raf".to_owned(), + polynomial_evals: vec![eq], + eval_families: Vec::new(), + product_families: vec![table_value_family, ra_product_family], + function_families: Vec::new(), + claim_value: claim_expr, + }, + } + } } #[derive(Clone, Debug, PartialEq, Eq)] @@ -106,6 +244,19 @@ pub(crate) struct Stage5InstructionReadRafPointValueEmitPlan { pub(crate) kind: Stage5InstructionReadRafPointValueKind, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Stage5InstructionReadRafOutputPlan { + pub(crate) field_exprs: Vec, + pub(crate) claim: SumcheckOutputClaimPlan, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Stage5InstructionReadRafOutputFieldExprPlan { + pub(crate) symbol: String, + pub(crate) formula: String, + pub(crate) operands: Vec, +} + impl Stage5InstructionReadRafPointValueEmitPlan { pub(crate) fn is_lookup_table(&self) -> bool { matches!( @@ -192,6 +343,18 @@ fn point_value_plans(table_count: usize) -> Vec, +) -> Stage5InstructionReadRafOutputFieldExprPlan { + Stage5InstructionReadRafOutputFieldExprPlan { + symbol, + formula: formula.to_owned(), + operands, + } +} + fn emit_point_value_constants(values: &[Stage5InstructionReadRafPointValueEmitPlan]) -> String { let values = values .iter() @@ -271,6 +434,65 @@ mod tests { Ok(()) } + #[test] + fn instruction_read_raf_output_claim_plan_is_typed() -> Result<(), EmitError> { + let plan = Stage5InstructionReadRafEmitPlan::from_evals([ + ( + "LookupTableFlag_0", + "stage5.instruction_read_raf.eval.LookupTableFlag_0", + ), + ( + "LookupTableFlag_1", + "stage5.instruction_read_raf.eval.LookupTableFlag_1", + ), + ( + "InstructionRa_0", + "stage5.instruction_read_raf.eval.InstructionRa_0", + ), + ])?; + let output_plan = plan.output_claim_plan(); + + assert_eq!( + output_plan.claim.relation, + "jolt.stage5.instruction_read_raf" + ); + assert_eq!( + output_plan.claim.claim_value, + "stage5.instruction_read_raf.output.claim_expr" + ); + assert_eq!(output_plan.claim.polynomial_evals.len(), 1); + assert_eq!( + output_plan.claim.polynomial_evals[0].symbol, + "stage5.instruction_read_raf.output.eq.LookupOutputCycle" + ); + assert_eq!(output_plan.claim.product_families.len(), 2); + assert_eq!( + output_plan.claim.product_families[0].symbol, + "stage5.instruction_read_raf.output.product.LookupTableValues" + ); + assert_eq!( + output_plan.claim.product_families[0].terms[0].evals, + vec![ + "stage5.instruction_read_raf.point_value.LookupTable_0".to_owned(), + "stage5.instruction_read_raf.eval.LookupTableFlag_0".to_owned() + ] + ); + assert_eq!( + output_plan.claim.product_families[1].terms[0].evals, + vec!["stage5.instruction_read_raf.eval.InstructionRa_0".to_owned()] + ); + assert!(output_plan.field_exprs.iter().any(|expr| { + expr.symbol == "stage5.instruction_read_raf.output.claim_expr" + && expr.formula == "field.mul" + && expr.operands + == vec![ + "stage5.instruction_read_raf.output.partial.EqRa".to_owned(), + "stage5.instruction_read_raf.output.partial.LookupOrRaf".to_owned(), + ] + })); + Ok(()) + } + #[test] fn instruction_read_raf_plan_rejects_non_contiguous_eval_families() -> Result<(), EmitError> { let error = match Stage5InstructionReadRafEmitPlan::from_evals([ From 327f30821f08eaeddc3aed892fbdeeeb41ab299c Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 02:32:30 -0600 Subject: [PATCH 074/171] refactor(bolt): plan stage6 bytecode output --- .../src/protocols/jolt/emit/rust/stage6.rs | 73 +++++++++++++------ .../jolt/stage6_bytecode_read_raf_plan.rs | 73 ++++++++++++++++++- .../jolt/verifier_jolt_relations.rs.template | 35 +++++++-- crates/bolt/tests/commitment_ir.rs | 30 +++++++- .../src/stages/jolt_relations.rs | 35 +++++++-- crates/jolt-verifier/src/stages/stage6.rs | 50 +++++++------ 6 files changed, 229 insertions(+), 67 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 5149ffb85b..571dec9056 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -11,7 +11,10 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::stage6_bytecode_read_raf_plan::emit_stage6_bytecode_read_raf_plan_constants; +use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ + emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_output_claim_plan, + stage6_bytecode_read_raf_output_contribution_symbol, +}; use crate::protocols::jolt::verifier_output_claims::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, @@ -632,7 +635,7 @@ impl Stage6CpuProgram { .map(|claim| claim.claim_value.as_str()), ); } - let output_claims = if role == Role::Verifier { + let mut output_claims = if role == Role::Verifier { verifier_output_claims::resolve_output_claims( "stage6", &output_values, @@ -645,6 +648,9 @@ impl Stage6CpuProgram { } else { Vec::new() }; + if role == Role::Verifier { + output_claims.push(stage6_bytecode_read_raf_output_claim_plan()); + } Ok(Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, @@ -777,6 +783,12 @@ impl Stage6CpuProgram { self.output_values.iter().map(|value| &value.symbol), verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), + verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + ); values.extend( self.output_families.iter().map(|family| &family.symbol), verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, @@ -793,10 +805,32 @@ impl Stage6CpuProgram { .map(|family| &family.symbol), verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), + verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, + ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), + verifier_output_claims::VerifierScalarSourceKind::OutputProductFamily, + ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), + verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, + ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), verifier_output_claims::VerifierScalarSourceKind::FieldExpr, ); + values.insert( + stage6_bytecode_read_raf_output_contribution_symbol(), + verifier_output_claims::VerifierScalarSourceKind::PointDerived, + ); values.extend( self.evals.iter().map(|eval| &eval.symbol), verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, @@ -1190,7 +1224,7 @@ impl Stage6CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ - use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\ + use super::jolt_relations::{evaluate_stage67_bytecode_read_raf_output_values, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -2579,7 +2613,18 @@ fn expected_batched_output_claim( .ok_or(VerifyStage6Error::MissingValue { symbol: "stage6.bytecode_read_raf.data", })?; - expected_bytecode_read_raf(program, data, store, evals, local_point)? + let mut local_store = store.clone(); + let log_t = stage6_trace_rounds(program)?; + evaluate_stage67_bytecode_read_raf_output_values( + &STAGE6_BYTECODE_PLAN, + &data.entries, + data.entry_bytecode_index, + data.num_lookup_tables, + &mut local_store, + local_point, + log_t, + )?; + expected_plan_output_claim(program, instance, &local_store, evals, local_point)? } Stage6RelationKind::Stage6Booleanity | Stage6RelationKind::Stage6HammingBooleanity @@ -2623,26 +2668,6 @@ fn expected_plan_output_claim( )?) } -fn expected_bytecode_read_raf( - program: &'static Stage6VerifierProgramPlan, - data: &Stage6BytecodeReadRafData, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - let log_t = stage6_trace_rounds(program)?; - Ok(evaluate_stage67_bytecode_read_raf( - &STAGE6_BYTECODE_PLAN, - &data.entries, - data.entry_bytecode_index, - data.num_lookup_tables, - store, - evals, - local_point, - log_t, - )?) -} - fn stage6_trace_rounds( program: &'static Stage6VerifierProgramPlan, ) -> Result { diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index ff4e693b26..82e52732f4 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -1,4 +1,7 @@ use crate::emit::rust::push_format; +use crate::protocols::jolt::verifier_output_claims::{ + SumcheckOutputClaimPlan, SumcheckOutputProductFamilyPlan, SumcheckOutputProductFamilyTermPlan, +}; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) struct BytecodeReadRafPlan { @@ -15,6 +18,7 @@ pub(crate) struct BytecodeReadRafPlan { pub(crate) stages: &'static [BytecodeReadRafStagePlan], pub(crate) output_terms_const: &'static str, pub(crate) output_terms: &'static [BytecodeOutputTermPlan], + pub(crate) output_contribution: &'static str, pub(crate) registers: BytecodeRegisterSymbols, pub(crate) entry_lookup_table: &'static str, } @@ -323,6 +327,7 @@ const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { stages: STAGE6_BYTECODE_STAGES, output_terms_const: "STAGE6_BYTECODE_OUTPUT_TERMS", output_terms: STAGE6_BYTECODE_OUTPUT_TERMS, + output_contribution: "stage6.bytecode_read_raf.output.contribution", registers: BytecodeRegisterSymbols { rd: "stage6.bytecode.entry.rd", rs1: "stage6.bytecode.entry.rs1", @@ -335,6 +340,38 @@ pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants() -> String { emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN) } +pub(crate) fn stage6_bytecode_read_raf_output_contribution_symbol() -> &'static str { + STAGE6_BYTECODE_READ_RAF_PLAN.output_contribution +} + +pub(crate) fn stage6_bytecode_read_raf_output_claim_plan() -> SumcheckOutputClaimPlan { + STAGE6_BYTECODE_READ_RAF_PLAN.output_claim_plan() +} + +impl BytecodeReadRafPlan { + fn output_claim_plan(&self) -> SumcheckOutputClaimPlan { + let product_family = SumcheckOutputProductFamilyPlan { + symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf".to_owned(), + gamma: None, + terms: vec![SumcheckOutputProductFamilyTermPlan { + gamma_power_offset: 0, + evals: std::iter::once(self.output_contribution.to_owned()) + .chain(self.bytecode_ra_evals.iter().map(|eval| (*eval).to_owned())) + .collect(), + factors: Vec::new(), + }], + }; + SumcheckOutputClaimPlan { + relation: "jolt.stage6.bytecode_read_raf".to_owned(), + polynomial_evals: Vec::new(), + eval_families: Vec::new(), + product_families: vec![product_family.clone()], + function_families: Vec::new(), + claim_value: product_family.symbol, + } + } +} + fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { let mut source = "\n".to_owned(); @@ -423,7 +460,7 @@ fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { push_format( &mut source, format_args!( - " point: {},\n gamma: {},\n bytecode_ra_evals: &{},\n entries: {},\n entry_bytecode_index: {},\n stages: {},\n output_terms: {},\n", + " point: {},\n gamma: {},\n bytecode_ra_evals: &{},\n entries: {},\n entry_bytecode_index: {},\n stages: {},\n output_terms: {},\n output_contribution: {},\n", rust_str(plan.point), rust_str(plan.gamma), plan.bytecode_ra_eval_family_const, @@ -431,6 +468,7 @@ fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { rust_str(plan.entry_bytecode_index), plan.stages_const, plan.output_terms_const, + rust_str(plan.output_contribution), ), ); source.push_str(" registers: Stage67BytecodeRegisterSymbols {\n"); @@ -541,7 +579,8 @@ fn rust_option_str(value: Option<&str>) -> String { #[cfg(test)] mod tests { use super::{ - emit_stage6_bytecode_read_raf_plan_constants, BytecodeFlag, BytecodeOutputTermPlan, + emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_output_claim_plan, + stage6_bytecode_read_raf_output_contribution_symbol, BytecodeFlag, BytecodeOutputTermPlan, BytecodeReadRafTermPlan, BytecodeRegister, STAGE6_BYTECODE_READ_RAF_PLAN, }; @@ -556,6 +595,10 @@ mod tests { plan.entry_lookup_table, "stage6.bytecode.entry.lookup_table" ); + assert_eq!( + plan.output_contribution, + "stage6.bytecode_read_raf.output.contribution" + ); let stage1 = &plan.stages[0]; assert_eq!(stage1.terms.len(), 16); @@ -631,6 +674,30 @@ mod tests { ); } + #[test] + fn stage6_bytecode_output_claim_plan_uses_point_derived_contribution() { + let claim = stage6_bytecode_read_raf_output_claim_plan(); + + assert_eq!(claim.relation, "jolt.stage6.bytecode_read_raf"); + assert_eq!( + claim.claim_value, + "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" + ); + assert!(claim.polynomial_evals.is_empty()); + assert!(claim.eval_families.is_empty()); + assert_eq!(claim.product_families.len(), 1); + assert_eq!(claim.product_families[0].terms.len(), 1); + assert_eq!( + claim.product_families[0].terms[0].evals, + vec![ + stage6_bytecode_read_raf_output_contribution_symbol().to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(), + ] + ); + } + #[test] fn stage6_bytecode_plan_renderer_emits_stage67_constants() { let source = emit_stage6_bytecode_read_raf_plan_constants(); @@ -645,6 +712,8 @@ mod tests { )); assert!(source.contains("const STAGE6_BYTECODE_OUTPUT_TERMS")); assert!(source.contains("Stage67BytecodeOutputTermPlan::Entry { gamma_power: 7 }")); + assert!(source + .contains("output_contribution: \"stage6.bytecode_read_raf.output.contribution\"")); assert!(source.contains("const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan")); } } diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index cce7fd7394..888bf39867 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -29,8 +29,8 @@ use jolt_lookup_tables::LookupTableKind; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - eval_family_values, field_powers, prefix_point, store_point, store_scalar, suffix_point, - NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, + field_powers, prefix_point, store_point, store_scalar, suffix_point, NamedEvalFamilyPlan, + RuntimePlanError, SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -121,6 +121,7 @@ pub struct Stage67BytecodeReadRafPlan { pub entry_bytecode_index: &'static str, pub stages: &'static [Stage67BytecodeStagePlan], pub output_terms: &'static [Stage67BytecodeOutputTermPlan], + pub output_contribution: &'static str, pub registers: Stage67BytecodeRegisterSymbols, pub entry_lookup_table: &'static str, } @@ -280,13 +281,34 @@ pub fn stage67_trace_rounds( }) } -pub fn evaluate_stage67_bytecode_read_raf( +pub fn evaluate_stage67_bytecode_read_raf_output_values( + plan: &Stage67BytecodeReadRafPlan, + entries: &[E], + entry_bytecode_index: usize, + num_lookup_tables: usize, + store: &mut ValueStore, + local_point: &[Fr], + log_t: usize, +) -> Result<(), RuntimePlanError> { + let output = stage67_bytecode_read_raf_output_contribution( + plan, + entries, + entry_bytecode_index, + num_lookup_tables, + store, + local_point, + log_t, + )?; + store.insert_scalar(plan.output_contribution, output); + Ok(()) +} + +fn stage67_bytecode_read_raf_output_contribution( plan: &Stage67BytecodeReadRafPlan, entries: &[E], entry_bytecode_index: usize, num_lookup_tables: usize, store: &ValueStore, - evals: &[StageNamedEval], local_point: &[Fr], log_t: usize, ) -> Result { @@ -315,10 +337,7 @@ pub fn evaluate_stage67_bytecode_read_raf( r_cycle_prime, log_k, )?; - let bytecode_ra = eval_family_values(evals, plan.bytecode_ra_evals)? - .into_iter() - .product::(); - Ok(output_contrib * bytecode_ra) + Ok(output_contrib) } fn stage67_bytecode_output_contribution( diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index c029212b7d..b0c5ad4376 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1532,7 +1532,7 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(verifier_program.output_families.len(), 1); assert_eq!(verifier_program.output_product_families.len(), 2); assert_eq!(verifier_program.output_function_families.len(), 2); - assert_eq!(verifier_program.output_claims.len(), 5); + assert_eq!(verifier_program.output_claims.len(), 6); let total_booleanity_ra = params.instruction_d + params.bytecode_d + params.ram_d; let booleanity_function_families = verifier_program .output_function_families @@ -1734,6 +1734,27 @@ fn stage6_rust_targets_extract_and_compile() { vec![instruction_product_family.clone()] ); assert!(instruction_ra_claims[0].function_families.is_empty()); + let bytecode_claims = verifier_program + .output_claims + .iter() + .filter(|claim| { + claim.claim_value == "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" + }) + .collect::>(); + assert_eq!(bytecode_claims.len(), 1); + assert!(bytecode_claims[0].polynomial_evals.is_empty()); + assert!(bytecode_claims[0].eval_families.is_empty()); + assert_eq!(bytecode_claims[0].product_families.len(), 1); + assert_eq!( + bytecode_claims[0].product_families[0].terms[0].evals, + vec![ + "stage6.bytecode_read_raf.output.contribution".to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned() + ] + ); + assert!(bytecode_claims[0].function_families.is_empty()); assert_eq!(prover_program.point_zeros.len(), 1); assert_eq!( prover_program.point_slices.len(), @@ -1805,7 +1826,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source.source.contains("Stage6VerifierData")); assert!(verifier_source.source.contains("Stage6BytecodeReadRafData")); assert!(verifier_source.source.contains("Stage6BytecodeEntry")); - assert!(verifier_source + assert!(!verifier_source .source .contains("expected_bytecode_read_raf")); assert!(verifier_source.source.contains("STAGE6_BYTECODE_PLAN")); @@ -1820,7 +1841,10 @@ fn stage6_rust_targets_extract_and_compile() { .contains("Stage67BytecodeTermPlan::RegisterEq")); assert!(verifier_source .source - .contains("evaluate_stage67_bytecode_read_raf")); + .contains("evaluate_stage67_bytecode_read_raf_output_values")); + assert!(verifier_source + .source + .contains("stage6.bytecode_read_raf.output.product.BytecodeReadRaf")); assert!(!verifier_source .source .contains("expected_stage67_bytecode_read_raf")); diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index cce7fd7394..888bf39867 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -29,8 +29,8 @@ use jolt_lookup_tables::LookupTableKind; use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ - eval_family_values, field_powers, prefix_point, store_point, store_scalar, suffix_point, - NamedEvalFamilyPlan, RuntimePlanError, StageNamedEval, SumcheckInstanceResultPlan, ValueStore, + field_powers, prefix_point, store_point, store_scalar, suffix_point, NamedEvalFamilyPlan, + RuntimePlanError, SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -121,6 +121,7 @@ pub struct Stage67BytecodeReadRafPlan { pub entry_bytecode_index: &'static str, pub stages: &'static [Stage67BytecodeStagePlan], pub output_terms: &'static [Stage67BytecodeOutputTermPlan], + pub output_contribution: &'static str, pub registers: Stage67BytecodeRegisterSymbols, pub entry_lookup_table: &'static str, } @@ -280,13 +281,34 @@ pub fn stage67_trace_rounds( }) } -pub fn evaluate_stage67_bytecode_read_raf( +pub fn evaluate_stage67_bytecode_read_raf_output_values( + plan: &Stage67BytecodeReadRafPlan, + entries: &[E], + entry_bytecode_index: usize, + num_lookup_tables: usize, + store: &mut ValueStore, + local_point: &[Fr], + log_t: usize, +) -> Result<(), RuntimePlanError> { + let output = stage67_bytecode_read_raf_output_contribution( + plan, + entries, + entry_bytecode_index, + num_lookup_tables, + store, + local_point, + log_t, + )?; + store.insert_scalar(plan.output_contribution, output); + Ok(()) +} + +fn stage67_bytecode_read_raf_output_contribution( plan: &Stage67BytecodeReadRafPlan, entries: &[E], entry_bytecode_index: usize, num_lookup_tables: usize, store: &ValueStore, - evals: &[StageNamedEval], local_point: &[Fr], log_t: usize, ) -> Result { @@ -315,10 +337,7 @@ pub fn evaluate_stage67_bytecode_read_raf( r_cycle_prime, log_k, )?; - let bytecode_ra = eval_family_values(evals, plan.bytecode_ra_evals)? - .into_iter() - .product::(); - Ok(output_contrib * bytecode_ra) + Ok(output_contrib) } fn stage67_bytecode_output_contribution( diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index a375b33ecf..263ee7de65 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; -use super::jolt_relations::{evaluate_stage67_bytecode_read_raf, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols}; +use super::jolt_relations::{evaluate_stage67_bytecode_read_raf_output_values, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -173,6 +173,7 @@ const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafP entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", stages: STAGE6_BYTECODE_STAGES, output_terms: STAGE6_BYTECODE_OUTPUT_TERMS, + output_contribution: "stage6.bytecode_read_raf.output.contribution", registers: Stage67BytecodeRegisterSymbols { rd: "stage6.bytecode.entry.rd", rs1: "stage6.bytecode.entry.rs1", @@ -799,12 +800,26 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES: &[bolt_verifier_runtime::Sumc bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage6.inc_claim_reduction.output.family", gamma: "stage6.inc_claim_reduction.gamma", evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_EVALS, power_stride: 2, value_term_offsets: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_VALUE_TERM_OFFSETS, shared_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_SHARED_TERMS, item_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERMS }, ]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ + +]; + +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &[]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERM_0_FACTORS }, +]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ + bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERMS }, +]; + pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[ Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6Booleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES, claim_value: "stage6.booleanity.output.family" }, Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILIES, claim_value: "stage6.hamming_booleanity.output.family" }, Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.ram_ra_virtual.output.family" }, Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.instruction_ra_virtual.output.family" }, Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES, product_families: &[], function_families: &[], claim_value: "stage6.inc_claim_reduction.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { @@ -1123,7 +1138,18 @@ fn expected_batched_output_claim( .ok_or(VerifyStage6Error::MissingValue { symbol: "stage6.bytecode_read_raf.data", })?; - expected_bytecode_read_raf(program, data, store, evals, local_point)? + let mut local_store = store.clone(); + let log_t = stage6_trace_rounds(program)?; + evaluate_stage67_bytecode_read_raf_output_values( + &STAGE6_BYTECODE_PLAN, + &data.entries, + data.entry_bytecode_index, + data.num_lookup_tables, + &mut local_store, + local_point, + log_t, + )?; + expected_plan_output_claim(program, instance, &local_store, evals, local_point)? } Stage6RelationKind::Stage6Booleanity | Stage6RelationKind::Stage6HammingBooleanity @@ -1167,26 +1193,6 @@ fn expected_plan_output_claim( )?) } -fn expected_bytecode_read_raf( - program: &'static Stage6VerifierProgramPlan, - data: &Stage6BytecodeReadRafData, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_point: &[Fr], -) -> Result { - let log_t = stage6_trace_rounds(program)?; - Ok(evaluate_stage67_bytecode_read_raf( - &STAGE6_BYTECODE_PLAN, - &data.entries, - data.entry_bytecode_index, - data.num_lookup_tables, - store, - evals, - local_point, - log_t, - )?) -} - fn stage6_trace_rounds( program: &'static Stage6VerifierProgramPlan, ) -> Result { From 5a684fbdc08f77b42b0108d32e6763442c46ef62 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 07:11:56 -0600 Subject: [PATCH 075/171] refactor(bolt): share output claim evaluation --- crates/bolt-verifier-runtime/src/lib.rs | 25 ++++++++++ .../src/protocols/jolt/emit/rust/stage3.rs | 13 ++---- .../src/protocols/jolt/emit/rust/stage4.rs | 13 ++---- .../src/protocols/jolt/emit/rust/stage5.rs | 46 ++++--------------- .../src/protocols/jolt/emit/rust/stage6.rs | 13 ++---- .../src/protocols/jolt/emit/rust/stage7.rs | 13 ++---- crates/bolt/tests/commitment_ir.rs | 4 +- crates/jolt-verifier/src/stages/stage3.rs | 13 ++---- crates/jolt-verifier/src/stages/stage4.rs | 13 ++---- crates/jolt-verifier/src/stages/stage5.rs | 46 ++++--------------- crates/jolt-verifier/src/stages/stage6.rs | 13 ++---- crates/jolt-verifier/src/stages/stage7.rs | 13 ++---- 12 files changed, 67 insertions(+), 158 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 01e2281c66..91f1c90ec8 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -1290,6 +1290,31 @@ pub fn evaluate_sumcheck_output_claim( }) } +pub fn evaluate_sumcheck_instance_output_claim( + output_claims: &[SumcheckOutputClaimPlan], + field_exprs: &[FieldExprPlan], + store: &ValueStore, + instance: &SumcheckInstanceResultPlan, + evals: &[StageNamedEval], + local_point: &[Fr], +) -> Result { + let output_claim = output_claims + .iter() + .find(|output_claim| output_claim.relation == instance.relation) + .ok_or(RuntimePlanError::InvalidProof { + driver: instance.symbol, + reason: "missing output claim for relation", + })?; + evaluate_sumcheck_output_claim( + output_claim, + field_exprs, + store, + instance.symbol, + evals, + local_point, + ) +} + fn evaluate_sumcheck_output_eval_family( family: &SumcheckOutputEvalFamilyPlan, store: &ValueStore, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index b97dec6ef3..58de2e0cfa 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -2295,18 +2295,11 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage3Error::UnsupportedRelation { - relation: instance.relation, - })?; - let value = bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + let value = bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, store, - instance.symbol, + instance, evals, local_point, )?; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index ea1aebc6c7..2005188a1c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -2546,18 +2546,11 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage4Error::UnsupportedRelation { - relation: instance.relation, - })?; - let value = bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + let value = bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, store, - instance.symbol, + instance, evals, local_point, )?; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 7c7a475fa3..e20b2190f5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -2469,58 +2469,28 @@ fn expected_batched_output_claim( }; let value = match relation { Stage5RelationKind::Stage5InstructionReadRaf => { - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage5Error::UnsupportedRelation { - relation: instance.relation, - })?; let mut local_store = store.clone(); evaluate_stage5_instruction_read_raf_point_values( &STAGE5_INSTRUCTION_READ_RAF_PLAN, &mut local_store, local_point, )?; - bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, &local_store, - instance.symbol, - evals, - local_point, - )? - } - Stage5RelationKind::Stage5RamRaClaimReduction => { - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage5Error::UnsupportedRelation { - relation: instance.relation, - })?; - bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, - program.field_exprs, - store, - instance.symbol, + instance, evals, local_point, )? } - Stage5RelationKind::Stage5RegistersValEvaluation => { - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage5Error::UnsupportedRelation { - relation: instance.relation, - })?; - bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + Stage5RelationKind::Stage5RamRaClaimReduction + | Stage5RelationKind::Stage5RegistersValEvaluation => { + bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, store, - instance.symbol, + instance, evals, local_point, )? diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 571dec9056..68e37c02e3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -2651,18 +2651,11 @@ fn expected_plan_output_claim( evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage6Error::UnsupportedRelation { - relation: instance.relation, - })?; - Ok(bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + Ok(bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, store, - instance.symbol, + instance, evals, local_point, )?) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index fdd13ae42e..27e5822c0a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -2482,18 +2482,11 @@ fn expected_batched_output_claim( }; let value = match relation { Stage7RelationKind::Stage7HammingWeightClaimReduction => { - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage7Error::UnsupportedRelation { - relation: instance.relation, - })?; - bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, store, - instance.symbol, + instance, evals, local_point, )? diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index b0c5ad4376..1998c49983 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1465,7 +1465,7 @@ fn stage5_rust_targets_extract_and_compile() { .contains("stage5.registers_val_evaluation.output.lt.RegistersValCycle")); assert!(verifier_source .source - .contains("bolt_verifier_runtime::evaluate_sumcheck_output_claim")); + .contains("bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim")); assert!(verifier_source .source .contains("Stage5RelationKind::Stage5RamRaClaimReduction")); @@ -2108,7 +2108,7 @@ fn stage7_rust_targets_extract_and_compile() { .contains("stage7.hamming_weight_claim_reduction.output.term")); assert!(verifier_source .source - .contains("bolt_verifier_runtime::evaluate_sumcheck_output_claim")); + .contains("bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim")); assert!(verifier_source .source .contains("stage7.input.stage6.booleanity.InstructionRa_0")); diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index e5f7157e0e..8dce502688 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -487,18 +487,11 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage3Error::UnsupportedRelation { - relation: instance.relation, - })?; - let value = bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + let value = bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, store, - instance.symbol, + instance, evals, local_point, )?; diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index aff57d8dee..3ab44f5c71 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -464,18 +464,11 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage4Error::UnsupportedRelation { - relation: instance.relation, - })?; - let value = bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + let value = bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, store, - instance.symbol, + instance, evals, local_point, )?; diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index d56d8bdbb5..a4085b5e6e 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -798,58 +798,28 @@ fn expected_batched_output_claim( }; let value = match relation { Stage5RelationKind::Stage5InstructionReadRaf => { - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage5Error::UnsupportedRelation { - relation: instance.relation, - })?; let mut local_store = store.clone(); evaluate_stage5_instruction_read_raf_point_values( &STAGE5_INSTRUCTION_READ_RAF_PLAN, &mut local_store, local_point, )?; - bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, &local_store, - instance.symbol, + instance, evals, local_point, )? } - Stage5RelationKind::Stage5RamRaClaimReduction => { - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage5Error::UnsupportedRelation { - relation: instance.relation, - })?; - bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, - program.field_exprs, - store, - instance.symbol, - evals, - local_point, - )? - } - Stage5RelationKind::Stage5RegistersValEvaluation => { - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage5Error::UnsupportedRelation { - relation: instance.relation, - })?; - bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + Stage5RelationKind::Stage5RamRaClaimReduction + | Stage5RelationKind::Stage5RegistersValEvaluation => { + bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, store, - instance.symbol, + instance, evals, local_point, )? diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 263ee7de65..5b8560bda8 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1176,18 +1176,11 @@ fn expected_plan_output_claim( evals: &[Stage6NamedEval], local_point: &[Fr], ) -> Result { - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage6Error::UnsupportedRelation { - relation: instance.relation, - })?; - Ok(bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + Ok(bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, store, - instance.symbol, + instance, evals, local_point, )?) diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index d48f506615..323ec4e26a 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -664,18 +664,11 @@ fn expected_batched_output_claim( }; let value = match relation { Stage7RelationKind::Stage7HammingWeightClaimReduction => { - let output_claim = program - .output_claims - .iter() - .find(|output_claim| output_claim.relation == instance.relation) - .ok_or(VerifyStage7Error::UnsupportedRelation { - relation: instance.relation, - })?; - bolt_verifier_runtime::evaluate_sumcheck_output_claim( - output_claim, + bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( + program.output_claims, program.field_exprs, store, - instance.symbol, + instance, evals, local_point, )? From 9c4db353b7b270e8079d2dd9f455878121409507 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 07:31:14 -0600 Subject: [PATCH 076/171] refactor(bolt): pass local output scalars --- crates/bolt-verifier-runtime/src/lib.rs | 12 +++++++ .../src/protocols/jolt/emit/rust/stage3.rs | 1 + .../src/protocols/jolt/emit/rust/stage4.rs | 1 + .../src/protocols/jolt/emit/rust/stage5.rs | 10 +++--- .../src/protocols/jolt/emit/rust/stage6.rs | 12 ++++--- .../src/protocols/jolt/emit/rust/stage7.rs | 1 + .../jolt/verifier_jolt_relations.rs.template | 31 ++++++++++++------- crates/bolt/tests/commitment_ir.rs | 4 +-- .../src/stages/jolt_relations.rs | 31 ++++++++++++------- crates/jolt-verifier/src/stages/stage3.rs | 1 + crates/jolt-verifier/src/stages/stage4.rs | 1 + crates/jolt-verifier/src/stages/stage5.rs | 10 +++--- crates/jolt-verifier/src/stages/stage6.rs | 12 ++++--- crates/jolt-verifier/src/stages/stage7.rs | 1 + 14 files changed, 82 insertions(+), 46 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 91f1c90ec8..846993052d 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -622,6 +622,12 @@ pub struct StageNamedEval { pub value: F, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct NamedScalar { + pub symbol: &'static str, + pub value: F, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct NamedEvalFamilyPlan { pub symbol: &'static str, @@ -1239,9 +1245,13 @@ pub fn evaluate_sumcheck_output_claim( store: &ValueStore, instance_symbol: &'static str, evals: &[StageNamedEval], + local_scalars: &[NamedScalar], local_point: &[Fr], ) -> Result { let mut scratch = ScratchScalars::default(); + for scalar in local_scalars { + scratch.insert(scalar.symbol, scalar.value); + } for eval in evals { scratch.insert(eval.name, eval.value); } @@ -1296,6 +1306,7 @@ pub fn evaluate_sumcheck_instance_output_claim( store: &ValueStore, instance: &SumcheckInstanceResultPlan, evals: &[StageNamedEval], + local_scalars: &[NamedScalar], local_point: &[Fr], ) -> Result { let output_claim = output_claims @@ -1311,6 +1322,7 @@ pub fn evaluate_sumcheck_instance_output_claim( store, instance.symbol, evals, + local_scalars, local_point, ) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 58de2e0cfa..ec1ef207f0 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -2301,6 +2301,7 @@ fn expected_batched_output_claim( store, instance, evals, + &[], local_point, )?; expected += *coefficient * value; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 2005188a1c..b82ce0dc0b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -2552,6 +2552,7 @@ fn expected_batched_output_claim( store, instance, evals, + &[], local_point, )?; expected += *coefficient * value; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index e20b2190f5..055f5a122b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1202,7 +1202,7 @@ impl Stage5CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan, NamedEvalFamilyPlan};\n\ - use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_values, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan};\n\ + use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -2469,18 +2469,17 @@ fn expected_batched_output_claim( }; let value = match relation { Stage5RelationKind::Stage5InstructionReadRaf => { - let mut local_store = store.clone(); - evaluate_stage5_instruction_read_raf_point_values( + let local_scalars = evaluate_stage5_instruction_read_raf_point_scalars( &STAGE5_INSTRUCTION_READ_RAF_PLAN, - &mut local_store, local_point, )?; bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( program.output_claims, program.field_exprs, - &local_store, + store, instance, evals, + &local_scalars, local_point, )? } @@ -2492,6 +2491,7 @@ fn expected_batched_output_claim( store, instance, evals, + &[], local_point, )? } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 68e37c02e3..9e6836eeb5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1224,7 +1224,7 @@ impl Stage6CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ - use super::jolt_relations::{evaluate_stage67_bytecode_read_raf_output_values, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\ + use super::jolt_relations::{evaluate_stage67_bytecode_read_raf_output_scalars, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -2613,18 +2613,17 @@ fn expected_batched_output_claim( .ok_or(VerifyStage6Error::MissingValue { symbol: "stage6.bytecode_read_raf.data", })?; - let mut local_store = store.clone(); let log_t = stage6_trace_rounds(program)?; - evaluate_stage67_bytecode_read_raf_output_values( + let local_scalars = evaluate_stage67_bytecode_read_raf_output_scalars( &STAGE6_BYTECODE_PLAN, &data.entries, data.entry_bytecode_index, data.num_lookup_tables, - &mut local_store, + store, local_point, log_t, )?; - expected_plan_output_claim(program, instance, &local_store, evals, local_point)? + expected_plan_output_claim(program, instance, store, evals, &local_scalars, local_point)? } Stage6RelationKind::Stage6Booleanity | Stage6RelationKind::Stage6HammingBooleanity @@ -2635,6 +2634,7 @@ fn expected_batched_output_claim( instance, store, evals, + &[], local_point, )?, relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }), @@ -2649,6 +2649,7 @@ fn expected_plan_output_claim( instance: &'static Stage6SumcheckInstanceResultPlan, store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], + local_scalars: &[bolt_verifier_runtime::NamedScalar], local_point: &[Fr], ) -> Result { Ok(bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( @@ -2657,6 +2658,7 @@ fn expected_plan_output_claim( store, instance, evals, + local_scalars, local_point, )?) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 27e5822c0a..ee867e4431 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -2488,6 +2488,7 @@ fn expected_batched_output_claim( store, instance, evals, + &[], local_point, )? } diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 888bf39867..e28cfba8a7 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -30,7 +30,7 @@ use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ field_powers, prefix_point, store_point, store_scalar, suffix_point, NamedEvalFamilyPlan, - RuntimePlanError, SumcheckInstanceResultPlan, ValueStore, + NamedScalar, RuntimePlanError, SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -214,17 +214,20 @@ pub trait Stage67BytecodeEntry { fn is_noop(&self) -> bool; } -pub fn evaluate_stage5_instruction_read_raf_point_values( +pub fn evaluate_stage5_instruction_read_raf_point_scalars( plan: &Stage5InstructionReadRafPlan, - store: &mut ValueStore, local_point: &[Fr], -) -> Result<(), RuntimePlanError> { +) -> Result>, RuntimePlanError> { let (r_address_prime, _) = instruction_read_raf_point_parts(plan, local_point)?; + let mut scalars = Vec::with_capacity(plan.point_values.len()); for value in plan.point_values { let scalar = evaluate_stage5_instruction_read_raf_point_value(value.kind, r_address_prime)?; - store.insert_scalar(value.symbol, scalar); + scalars.push(NamedScalar { + symbol: value.symbol, + value: scalar, + }); } - Ok(()) + Ok(scalars) } fn evaluate_stage5_instruction_read_raf_point_value( @@ -250,7 +253,9 @@ fn evaluate_stage5_instruction_read_raf_point_value( Stage5InstructionReadRafPointValueKind::RightOperand => { operand_polynomial_eval(r_address_prime, false) } - Stage5InstructionReadRafPointValueKind::Identity => identity_polynomial_eval(r_address_prime), + Stage5InstructionReadRafPointValueKind::Identity => { + identity_polynomial_eval(r_address_prime) + } }) } @@ -281,15 +286,15 @@ pub fn stage67_trace_rounds( }) } -pub fn evaluate_stage67_bytecode_read_raf_output_values( +pub fn evaluate_stage67_bytecode_read_raf_output_scalars( plan: &Stage67BytecodeReadRafPlan, entries: &[E], entry_bytecode_index: usize, num_lookup_tables: usize, - store: &mut ValueStore, + store: &ValueStore, local_point: &[Fr], log_t: usize, -) -> Result<(), RuntimePlanError> { +) -> Result>, RuntimePlanError> { let output = stage67_bytecode_read_raf_output_contribution( plan, entries, @@ -299,8 +304,10 @@ pub fn evaluate_stage67_bytecode_read_raf_output_values local_point, log_t, )?; - store.insert_scalar(plan.output_contribution, output); - Ok(()) + Ok(vec![NamedScalar { + symbol: plan.output_contribution, + value: output, + }]) } fn stage67_bytecode_read_raf_output_contribution( diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 1998c49983..424e0122a3 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1438,7 +1438,7 @@ fn stage5_rust_targets_extract_and_compile() { .contains("relation: Some(Stage5RelationKind::Stage5Batched)")); assert!(verifier_source .source - .contains("evaluate_stage5_instruction_read_raf_point_values")); + .contains("evaluate_stage5_instruction_read_raf_point_scalars")); assert!(verifier_source .source .contains("Stage5RelationKind::Stage5InstructionReadRaf")); @@ -1841,7 +1841,7 @@ fn stage6_rust_targets_extract_and_compile() { .contains("Stage67BytecodeTermPlan::RegisterEq")); assert!(verifier_source .source - .contains("evaluate_stage67_bytecode_read_raf_output_values")); + .contains("evaluate_stage67_bytecode_read_raf_output_scalars")); assert!(verifier_source .source .contains("stage6.bytecode_read_raf.output.product.BytecodeReadRaf")); diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 888bf39867..e28cfba8a7 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -30,7 +30,7 @@ use jolt_poly::EqPolynomial; use bolt_verifier_runtime::{ field_powers, prefix_point, store_point, store_scalar, suffix_point, NamedEvalFamilyPlan, - RuntimePlanError, SumcheckInstanceResultPlan, ValueStore, + NamedScalar, RuntimePlanError, SumcheckInstanceResultPlan, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -214,17 +214,20 @@ pub trait Stage67BytecodeEntry { fn is_noop(&self) -> bool; } -pub fn evaluate_stage5_instruction_read_raf_point_values( +pub fn evaluate_stage5_instruction_read_raf_point_scalars( plan: &Stage5InstructionReadRafPlan, - store: &mut ValueStore, local_point: &[Fr], -) -> Result<(), RuntimePlanError> { +) -> Result>, RuntimePlanError> { let (r_address_prime, _) = instruction_read_raf_point_parts(plan, local_point)?; + let mut scalars = Vec::with_capacity(plan.point_values.len()); for value in plan.point_values { let scalar = evaluate_stage5_instruction_read_raf_point_value(value.kind, r_address_prime)?; - store.insert_scalar(value.symbol, scalar); + scalars.push(NamedScalar { + symbol: value.symbol, + value: scalar, + }); } - Ok(()) + Ok(scalars) } fn evaluate_stage5_instruction_read_raf_point_value( @@ -250,7 +253,9 @@ fn evaluate_stage5_instruction_read_raf_point_value( Stage5InstructionReadRafPointValueKind::RightOperand => { operand_polynomial_eval(r_address_prime, false) } - Stage5InstructionReadRafPointValueKind::Identity => identity_polynomial_eval(r_address_prime), + Stage5InstructionReadRafPointValueKind::Identity => { + identity_polynomial_eval(r_address_prime) + } }) } @@ -281,15 +286,15 @@ pub fn stage67_trace_rounds( }) } -pub fn evaluate_stage67_bytecode_read_raf_output_values( +pub fn evaluate_stage67_bytecode_read_raf_output_scalars( plan: &Stage67BytecodeReadRafPlan, entries: &[E], entry_bytecode_index: usize, num_lookup_tables: usize, - store: &mut ValueStore, + store: &ValueStore, local_point: &[Fr], log_t: usize, -) -> Result<(), RuntimePlanError> { +) -> Result>, RuntimePlanError> { let output = stage67_bytecode_read_raf_output_contribution( plan, entries, @@ -299,8 +304,10 @@ pub fn evaluate_stage67_bytecode_read_raf_output_values local_point, log_t, )?; - store.insert_scalar(plan.output_contribution, output); - Ok(()) + Ok(vec![NamedScalar { + symbol: plan.output_contribution, + value: output, + }]) } fn stage67_bytecode_read_raf_output_contribution( diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 8dce502688..5715ad2bea 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -493,6 +493,7 @@ fn expected_batched_output_claim( store, instance, evals, + &[], local_point, )?; expected += *coefficient * value; diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 3ab44f5c71..c564bace9c 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -470,6 +470,7 @@ fn expected_batched_output_claim( store, instance, evals, + &[], local_point, )?; expected += *coefficient * value; diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index a4085b5e6e..bdfd91283d 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{batch_claims, find_batch, find_plan, NamedEvalFamilyPlan}; -use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_values, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan}; +use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -798,18 +798,17 @@ fn expected_batched_output_claim( }; let value = match relation { Stage5RelationKind::Stage5InstructionReadRaf => { - let mut local_store = store.clone(); - evaluate_stage5_instruction_read_raf_point_values( + let local_scalars = evaluate_stage5_instruction_read_raf_point_scalars( &STAGE5_INSTRUCTION_READ_RAF_PLAN, - &mut local_store, local_point, )?; bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( program.output_claims, program.field_exprs, - &local_store, + store, instance, evals, + &local_scalars, local_point, )? } @@ -821,6 +820,7 @@ fn expected_batched_output_claim( store, instance, evals, + &[], local_point, )? } diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 5b8560bda8..08b41739b9 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; -use super::jolt_relations::{evaluate_stage67_bytecode_read_raf_output_values, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols}; +use super::jolt_relations::{evaluate_stage67_bytecode_read_raf_output_scalars, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -1138,18 +1138,17 @@ fn expected_batched_output_claim( .ok_or(VerifyStage6Error::MissingValue { symbol: "stage6.bytecode_read_raf.data", })?; - let mut local_store = store.clone(); let log_t = stage6_trace_rounds(program)?; - evaluate_stage67_bytecode_read_raf_output_values( + let local_scalars = evaluate_stage67_bytecode_read_raf_output_scalars( &STAGE6_BYTECODE_PLAN, &data.entries, data.entry_bytecode_index, data.num_lookup_tables, - &mut local_store, + store, local_point, log_t, )?; - expected_plan_output_claim(program, instance, &local_store, evals, local_point)? + expected_plan_output_claim(program, instance, store, evals, &local_scalars, local_point)? } Stage6RelationKind::Stage6Booleanity | Stage6RelationKind::Stage6HammingBooleanity @@ -1160,6 +1159,7 @@ fn expected_batched_output_claim( instance, store, evals, + &[], local_point, )?, relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }), @@ -1174,6 +1174,7 @@ fn expected_plan_output_claim( instance: &'static Stage6SumcheckInstanceResultPlan, store: &bolt_verifier_runtime::ValueStore, evals: &[Stage6NamedEval], + local_scalars: &[bolt_verifier_runtime::NamedScalar], local_point: &[Fr], ) -> Result { Ok(bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( @@ -1182,6 +1183,7 @@ fn expected_plan_output_claim( store, instance, evals, + local_scalars, local_point, )?) } diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 323ec4e26a..3fd065709a 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -670,6 +670,7 @@ fn expected_batched_output_claim( store, instance, evals, + &[], local_point, )? } From 8fc7688a7112988ee4c9fc042c2df73e82a86be0 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 07:40:06 -0600 Subject: [PATCH 077/171] refactor(bolt): declare output claim local scalars --- crates/bolt-verifier-runtime/src/lib.rs | 6 +++++ .../protocols/jolt/emit/rust/output_claims.rs | 24 ++++++++++++++++++- .../src/protocols/jolt/emit/rust/stage5.rs | 12 +++++----- .../src/protocols/jolt/emit/rust/stage6.rs | 7 +++--- .../jolt/stage5_instruction_read_raf_plan.rs | 15 ++++++++++++ .../jolt/stage6_bytecode_read_raf_plan.rs | 6 +++++ .../protocols/jolt/verifier_output_claims.rs | 2 ++ crates/jolt-verifier/src/stages/stage3.rs | 6 ++--- crates/jolt-verifier/src/stages/stage4.rs | 4 ++-- crates/jolt-verifier/src/stages/stage5.rs | 7 +++--- crates/jolt-verifier/src/stages/stage6.rs | 13 +++++----- crates/jolt-verifier/src/stages/stage7.rs | 2 +- 12 files changed, 79 insertions(+), 25 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 846993052d..1b3b28d9ef 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -442,6 +442,7 @@ pub struct SumcheckOutputClaimPlan { pub eval_families: &'static [SumcheckOutputEvalFamilyPlan], pub product_families: &'static [SumcheckOutputProductFamilyPlan], pub function_families: &'static [SumcheckOutputFunctionFamilyPlan], + pub local_scalars: &'static [&'static str], pub claim_value: &'static str, } @@ -1252,6 +1253,11 @@ pub fn evaluate_sumcheck_output_claim( for scalar in local_scalars { scratch.insert(scalar.symbol, scalar.value); } + for symbol in plan.local_scalars { + if !local_scalars.iter().any(|scalar| scalar.symbol == *symbol) { + return Err(RuntimePlanError::MissingValue { symbol }); + } + } for eval in evals { scratch.insert(eval.name, eval.value); } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index 064df5c933..8356311b25 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -42,8 +42,9 @@ pub fn emit_verifier_output_claim_constants( let product_families = emit_product_family_constants(&mut source, stage_type, index, claim); let function_families = emit_function_family_constants(&mut source, stage_type, index, claim)?; + let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim); claims.push(format!( - " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, product_families: {product_families}, function_families: {function_families}, claim_value: {} }},", + " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, product_families: {product_families}, function_families: {function_families}, local_scalars: {local_scalars}, claim_value: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, rust_str(&claim.claim_value) )); @@ -59,6 +60,27 @@ pub fn emit_verifier_output_claim_constants( Ok(source) } +fn emit_local_scalar_constants( + source: &mut String, + stage_type: &str, + claim_index: usize, + claim: &SumcheckOutputClaimPlan, +) -> String { + if claim.local_scalars.is_empty() { + return "&[]".to_owned(); + } + let name = format!( + "{}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_LOCAL_SCALARS", + stage_type.to_ascii_uppercase() + ); + let scalars = rust_str_array(&claim.local_scalars); + push_format( + source, + format_args!("pub const {name}: &[&str] = &[{scalars}];\n"), + ); + name +} + fn emit_eval_family_constants( source: &mut String, stage_type: &str, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 055f5a122b..b35f965340 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -805,12 +805,12 @@ impl Stage5CpuProgram { self.field_exprs.iter().map(|expr| &expr.symbol), verifier_output_claims::VerifierScalarSourceKind::FieldExpr, ); - if let Some(plan) = &self.instruction_read_raf_plan { - values.extend( - plan.point_values.iter().map(|value| &value.symbol), - verifier_output_claims::VerifierScalarSourceKind::PointDerived, - ); - } + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.local_scalars.iter()), + verifier_output_claims::VerifierScalarSourceKind::PointDerived, + ); values.extend( self.evals.iter().map(|eval| &eval.symbol), verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 9e6836eeb5..eea1fdd044 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -13,7 +13,6 @@ use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_output_claim_plan, - stage6_bytecode_read_raf_output_contribution_symbol, }; use crate::protocols::jolt::verifier_output_claims::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, @@ -827,8 +826,10 @@ impl Stage6CpuProgram { self.field_exprs.iter().map(|expr| &expr.symbol), verifier_output_claims::VerifierScalarSourceKind::FieldExpr, ); - values.insert( - stage6_bytecode_read_raf_output_contribution_symbol(), + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.local_scalars.iter()), verifier_output_claims::VerifierScalarSourceKind::PointDerived, ); values.extend( diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 07892a0b2f..109caf4baf 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -232,6 +232,11 @@ impl Stage5InstructionReadRafEmitPlan { eval_families: Vec::new(), product_families: vec![table_value_family, ra_product_family], function_families: Vec::new(), + local_scalars: self + .point_values + .iter() + .map(|value| value.symbol.clone()) + .collect(), claim_value: claim_expr, }, } @@ -481,6 +486,16 @@ mod tests { output_plan.claim.product_families[1].terms[0].evals, vec!["stage5.instruction_read_raf.eval.InstructionRa_0".to_owned()] ); + assert_eq!( + output_plan.claim.local_scalars, + vec![ + "stage5.instruction_read_raf.point_value.LookupTable_0".to_owned(), + "stage5.instruction_read_raf.point_value.LookupTable_1".to_owned(), + "stage5.instruction_read_raf.point_value.LeftLookupOperand".to_owned(), + "stage5.instruction_read_raf.point_value.RightLookupOperand".to_owned(), + "stage5.instruction_read_raf.point_value.Identity".to_owned(), + ] + ); assert!(output_plan.field_exprs.iter().any(|expr| { expr.symbol == "stage5.instruction_read_raf.output.claim_expr" && expr.formula == "field.mul" diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 82e52732f4..4c5e5c9919 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -340,6 +340,7 @@ pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants() -> String { emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN) } +#[cfg(test)] pub(crate) fn stage6_bytecode_read_raf_output_contribution_symbol() -> &'static str { STAGE6_BYTECODE_READ_RAF_PLAN.output_contribution } @@ -367,6 +368,7 @@ impl BytecodeReadRafPlan { eval_families: Vec::new(), product_families: vec![product_family.clone()], function_families: Vec::new(), + local_scalars: vec![self.output_contribution.to_owned()], claim_value: product_family.symbol, } } @@ -687,6 +689,10 @@ mod tests { assert!(claim.eval_families.is_empty()); assert_eq!(claim.product_families.len(), 1); assert_eq!(claim.product_families[0].terms.len(), 1); + assert_eq!( + claim.local_scalars, + vec![stage6_bytecode_read_raf_output_contribution_symbol().to_owned()] + ); assert_eq!( claim.product_families[0].terms[0].evals, vec![ diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index 710c0f171a..e37d2aed49 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -214,6 +214,7 @@ pub struct SumcheckOutputClaimPlan { pub eval_families: Vec, pub product_families: Vec, pub function_families: Vec, + pub local_scalars: Vec, pub claim_value: String, } @@ -703,6 +704,7 @@ where eval_families, product_families, function_families, + local_scalars: Vec::new(), claim_value: claim.claim_value, }) }) diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 5715ad2bea..dc4864c836 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -224,9 +224,9 @@ pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage3StructuredPolynomialEva ]; pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[ - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage3.spartan_shift.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage3.instruction_input.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage3.registers.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage3.spartan_shift.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage3.instruction_input.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index c564bace9c..02b83ad96c 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -183,8 +183,8 @@ pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage4StructuredPolynomialEva ]; pub const STAGE4_SUMCHECK_OUTPUT_CLAIMS: &[Stage4SumcheckOutputClaimPlan] = &[ - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage4.registers_read_write.output.claim_expr" }, - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage4.ram_val_check.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage4.registers_read_write.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index bdfd91283d..b50130e41d 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -507,10 +507,11 @@ pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runti bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", gamma: None, terms: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERMS }, ]; +pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIMS: &[Stage5SumcheckOutputClaimPlan] = &[ - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage5.instruction_read_raf.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_LOCAL_SCALARS, claim_value: "stage5.instruction_read_raf.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 08b41739b9..802ab9d1d2 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -813,13 +813,14 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES: &[bolt_verifier_runti bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERMS }, ]; +pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[ - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6Booleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES, claim_value: "stage6.booleanity.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILIES, claim_value: "stage6.hamming_booleanity.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.ram_ra_virtual.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.instruction_ra_virtual.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES, product_families: &[], function_families: &[], claim_value: "stage6.inc_claim_reduction.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES, function_families: &[], claim_value: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6Booleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES, local_scalars: &[], claim_value: "stage6.booleanity.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILIES, local_scalars: &[], claim_value: "stage6.hamming_booleanity.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], claim_value: "stage6.ram_ra_virtual.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], claim_value: "stage6.instruction_ra_virtual.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage6.inc_claim_reduction.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_LOCAL_SCALARS, claim_value: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 3fd065709a..4a9bcce3c5 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -288,7 +288,7 @@ pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES: &[bolt_verifier_runtime::Sumc ]; pub const STAGE7_SUMCHECK_OUTPUT_CLAIMS: &[Stage7SumcheckOutputClaimPlan] = &[ - Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES, product_families: &[], function_families: &[], claim_value: "stage7.hamming_weight_claim_reduction.output.family" }, + Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage7.hamming_weight_claim_reduction.output.family" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ From 751d447d07c6ae3f44e4bf95a24db74c3433f51a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 07:54:32 -0600 Subject: [PATCH 078/171] refactor(bolt): plan stage5 verifier emission Route Stage 5 verifier constants through the shared verifier-stage plan where the plan already has typed shapes. Compact small generated output-family slices so checked-in verifier metrics stay under the current readability LOC gate. --- .../protocols/jolt/emit/rust/output_claims.rs | 63 ++-- .../src/protocols/jolt/emit/rust/stage5.rs | 293 +++++++++++++++--- crates/jolt-verifier/src/stages/stage5.rs | 167 +++------- crates/jolt-verifier/src/stages/stage6.rs | 169 ++++------ crates/jolt-verifier/src/stages/stage7.rs | 3 +- 5 files changed, 374 insertions(+), 321 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index 8356311b25..46ca003869 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -102,11 +102,8 @@ fn emit_eval_family_constants( format_args!("pub const {evals_name}: &[&str] = &[{evals}];\n"), ); let value_offsets_name = format!("{prefix}_VALUE_TERM_OFFSETS"); - let value_offsets = usize_array(&family.value_term_offsets); - push_format( - source, - format_args!("pub const {value_offsets_name}: &[usize] = &[{value_offsets}];\n"), - ); + let value_offsets = + emit_usize_slice_or_inline(source, &value_offsets_name, &family.value_term_offsets); let shared_terms_name = format!("{prefix}_SHARED_TERMS"); let shared_terms = family .shared_terms @@ -130,13 +127,9 @@ fn emit_eval_family_constants( let mut item_rows = Vec::new(); for (term_index, term) in family.item_terms.iter().enumerate() { let factors_name = format!("{prefix}_ITEM_TERM_{term_index}_FACTORS"); - let factors = rust_str_array(&term.factors); - push_format( - source, - format_args!("pub const {factors_name}: &[&str] = &[{factors}];\n"), - ); + let factors = emit_str_slice_or_inline(source, &factors_name, &term.factors); item_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan {{ gamma_power_offset: {}, factors: {factors_name} }},", + " bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan {{ gamma_power_offset: {}, factors: {factors} }},", term.gamma_power_offset )); } @@ -149,7 +142,7 @@ fn emit_eval_family_constants( ), ); family_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan {{ symbol: {}, gamma: {}, evals: {evals_name}, power_stride: {}, value_term_offsets: {value_offsets_name}, shared_terms: {shared_terms_name}, item_terms: {item_terms_name} }},", + " bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan {{ symbol: {}, gamma: {}, evals: {evals_name}, power_stride: {}, value_term_offsets: {value_offsets}, shared_terms: {shared_terms_name}, item_terms: {item_terms_name} }},", rust_str(&family.symbol), rust_str(&family.gamma), family.power_stride @@ -184,19 +177,11 @@ fn emit_product_family_constants( let mut term_rows = Vec::new(); for (term_index, term) in family.terms.iter().enumerate() { let evals_name = format!("{prefix}_TERM_{term_index}_EVALS"); - let evals = rust_str_array(&term.evals); - push_format( - source, - format_args!("pub const {evals_name}: &[&str] = &[{evals}];\n"), - ); + let evals = emit_str_slice_or_inline(source, &evals_name, &term.evals); let factors_name = format!("{prefix}_TERM_{term_index}_FACTORS"); - let factors = rust_str_array(&term.factors); - push_format( - source, - format_args!("pub const {factors_name}: &[&str] = &[{factors}];\n"), - ); + let factors = emit_str_slice_or_inline(source, &factors_name, &term.factors); term_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan {{ gamma_power_offset: {}, evals: {evals_name}, factors: {factors_name} }},", + " bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan {{ gamma_power_offset: {}, evals: {evals}, factors: {factors} }},", term.gamma_power_offset )); } @@ -244,13 +229,9 @@ fn emit_function_family_constants( let mut term_rows = Vec::new(); for (term_index, term) in family.terms.iter().enumerate() { let factors_name = format!("{prefix}_TERM_{term_index}_FACTORS"); - let factors = rust_str_array(&term.factors); - push_format( - source, - format_args!("pub const {factors_name}: &[&str] = &[{factors}];\n"), - ); + let factors = emit_str_slice_or_inline(source, &factors_name, &term.factors); term_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan {{ gamma_power_offset: {}, function: {}, eval: {}, factors: {factors_name} }},", + " bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan {{ gamma_power_offset: {}, function: {}, eval: {}, factors: {factors} }},", term.gamma_power_offset, output_function_kind_expr(term.function), rust_str(&term.eval) @@ -290,6 +271,30 @@ fn output_function_kind_expr(function: SumcheckOutputFunctionKind) -> &'static s } } +fn emit_str_slice_or_inline(source: &mut String, name: &str, values: &[String]) -> String { + if values.len() <= 4 { + return format!("&[{}]", rust_str_array(values)); + } + let values = rust_str_array(values); + push_format( + source, + format_args!("pub const {name}: &[&str] = &[{values}];\n"), + ); + name.to_owned() +} + +fn emit_usize_slice_or_inline(source: &mut String, name: &str, values: &[usize]) -> String { + if values.len() <= 4 { + return format!("&[{}]", usize_array(values)); + } + let values = usize_array(values); + push_format( + source, + format_args!("pub const {name}: &[usize] = &[{values}];\n"), + ); + name.to_owned() +} + fn structured_polynomial_kind_expr( stage_type: &str, polynomial: StructuredPolynomialKind, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index b35f965340..503ea277a3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -25,12 +25,14 @@ use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputFunctionFamilyPlan as Stage5SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan as Stage5SumcheckOutputProductFamilyPlan, }; +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5CpuProgram { pub role: Role, pub(crate) instruction_read_raf_plan: Option, + pub(crate) verifier_plan: Option, pub params: Stage5Params, pub steps: Vec, pub transcript_squeezes: Vec, @@ -593,6 +595,7 @@ impl Stage5CpuProgram { let role = module .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; + let is_verifier = role == Role::Verifier; if role == Role::Prover { verifier_output_claims::prune_output_only_field_exprs( &mut field_exprs, @@ -630,10 +633,11 @@ impl Stage5CpuProgram { output_claims.push(output_plan.claim); } - Ok(Self { + let mut program = Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, role, instruction_read_raf_plan, + verifier_plan: None, steps, transcript_squeezes, transcript_absorb_bytes, @@ -656,9 +660,170 @@ impl Stage5CpuProgram { opening_claims, opening_equalities, opening_batches, + }; + if is_verifier { + program.verifier_plan = Some(program.plan_verifier()?); + } + Ok(program) + } + + fn plan_verifier(&self) -> Result { + Ok(VerifierStagePlan { + steps: self + .steps + .iter() + .map(|step| { + verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) + }) + .collect::, EmitError>>()?, + transcript_squeezes: self + .transcript_squeezes + .iter() + .map(|squeeze| { + verifier_plan::VerifierTranscriptSqueezePlan::from_cpu( + &squeeze.symbol, + &squeeze.label, + &squeeze.kind, + squeeze.count, + ) + }) + .collect::, EmitError>>()?, + transcript_absorb_bytes: self + .transcript_absorb_bytes + .iter() + .map(|absorb| { + verifier_plan::VerifierTranscriptAbsorbBytesPlan::from_cpu( + &absorb.symbol, + &absorb.label, + &absorb.payload, + ) + }) + .collect(), + opening_inputs: self + .opening_inputs + .iter() + .map(|input| { + verifier_plan::VerifierOpeningInputPlan::from_cpu( + &input.symbol, + &input.source_stage, + &input.source_claim, + &input.oracle, + &input.domain, + input.point_arity, + &input.claim_kind, + ) + }) + .collect::, EmitError>>()?, + field_exprs: self + .field_exprs + .iter() + .map(|expr| { + verifier_plan::VerifierFieldExprPlan::from_cpu( + &expr.symbol, + &expr.formula, + &expr.operands, + ) + }) + .collect::, EmitError>>()?, + claims: self + .claims + .iter() + .map(|claim| { + Ok(verifier_plan::VerifierSumcheckClaimPlan { + symbol: claim.symbol.clone(), + stage: claim.stage.clone(), + domain: claim.domain.clone(), + num_rounds: claim.num_rounds, + degree: claim.degree, + claim: claim.claim.clone(), + relation: verifier_plan::required_relation_from_cpu( + claim.relation.as_deref(), + "claim", + &claim.symbol, + )?, + claim_value: claim.claim_value.clone(), + }) + }) + .collect::, EmitError>>()?, + drivers: self + .drivers + .iter() + .map(|driver| { + Ok(verifier_plan::VerifierSumcheckDriverPlan { + symbol: driver.symbol.clone(), + stage: driver.stage.clone(), + proof_slot: driver.proof_slot.clone(), + relation: verifier_plan::required_relation_from_cpu( + driver.relation.as_deref(), + "driver", + &driver.symbol, + )?, + batch: driver.batch.clone(), + policy: driver.policy.clone(), + round_schedule: driver.round_schedule.clone(), + claim_label: driver.claim_label.clone(), + round_label: driver.round_label.clone(), + num_rounds: driver.num_rounds, + degree: driver.degree, + }) + }) + .collect::, EmitError>>()?, + instance_results: self + .instance_results + .iter() + .map(|instance| { + Ok(verifier_plan::VerifierSumcheckInstanceResultPlan { + symbol: instance.symbol.clone(), + source: instance.source.clone(), + claim: instance.claim.clone(), + relation: verifier_plan::relation_from_cpu(&instance.relation)?, + index: instance.index, + point_arity: instance.point_arity, + num_rounds: instance.num_rounds, + round_offset: instance.round_offset, + point_order: verifier_plan::sumcheck_point_order_from_cpu( + &instance.point_order, + )?, + degree: instance.degree, + }) + }) + .collect::, EmitError>>()?, + opening_claims: self + .opening_claims + .iter() + .map(|claim| { + Ok(verifier_plan::VerifierOpeningClaimPlan { + symbol: claim.symbol.clone(), + oracle: claim.oracle.clone(), + domain: claim.domain.clone(), + point_arity: claim.point_arity, + claim_kind: verifier_plan::claim_kind_from_cpu(&claim.claim_kind)?, + point_source: claim.point_source.clone(), + eval_source: claim.eval_source.clone(), + }) + }) + .collect::, EmitError>>()?, + opening_equalities: self + .opening_equalities + .iter() + .map(|equality| { + Ok(verifier_plan::VerifierOpeningClaimEqualityPlan { + symbol: equality.symbol.clone(), + mode: verifier_plan::opening_equality_mode_from_cpu(&equality.mode)?, + lhs: equality.lhs.clone(), + rhs: equality.rhs.clone(), + }) + }) + .collect::, EmitError>>()?, }) } + fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { + self.verifier_plan + .as_ref() + .ok_or_else(|| EmitError::new("missing stage5 verifier plan")) + } + fn verify_supported_target(&self) -> Result<(), EmitError> { require_supported_symbol("field", &self.params.field, "bn254_fr")?; require_supported_symbol("pcs", &self.params.pcs, "dory")?; @@ -1539,7 +1704,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); ); source.push_str(&self.emit_program_step_constants()?); source.push_str(&self.emit_transcript_squeeze_constants()?); - source.push_str(&self.emit_transcript_absorb_bytes_constants()); + source.push_str(&self.emit_transcript_absorb_bytes_constants()?); source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); @@ -1547,6 +1712,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_program_step_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_program_step_constants( + "Stage5", + "STAGE5", + &plan.steps, + )); + } let steps = self .steps .iter() @@ -1567,6 +1740,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_transcript_squeeze_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_transcript_squeeze_constants( + "Stage5", + "STAGE5", + &plan.transcript_squeezes, + )); + } let squeezes = self .transcript_squeezes .iter() @@ -1586,7 +1767,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); )) } - fn emit_transcript_absorb_bytes_constants(&self) -> String { + fn emit_transcript_absorb_bytes_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_transcript_absorb_bytes_constants( + "Stage5", + "STAGE5", + &plan.transcript_absorb_bytes, + )); + } let absorbs = self .transcript_absorb_bytes .iter() @@ -1600,12 +1789,20 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); }) .collect::>() .join("\n"); - format!( + Ok(format!( "pub const STAGE5_TRANSCRIPT_ABSORB_BYTES: &[Stage5TranscriptAbsorbBytesPlan] = &[\n{absorbs}\n];\n\n" - ) + )) } fn emit_opening_input_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_input_constants( + "Stage5", + "STAGE5", + &plan.opening_inputs, + )); + } let inputs = self .opening_inputs .iter() @@ -1649,25 +1846,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { - let exprs = self - .field_exprs - .iter() - .map(|expr| { - Ok(format!( - " Stage5FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", - rust_str(&expr.symbol), - super::plan_tokens::role_field_expr_kind_expr( - "Stage5", - &self.role, - &expr.formula - )?, - super::plan_tokens::rust_str_slice_expr(&expr.operands) - )) - }) - .collect::, EmitError>>()? - .join("\n"); - return Ok(format!( - "pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[\n{exprs}\n];\n" + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_field_expr_constants( + "Stage5", + "STAGE5", + &plan.field_exprs, )); } @@ -1734,31 +1917,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); fn emit_sumcheck_claim_constants(&self) -> Result { if self.role == Role::Verifier { - let claims = self - .claims - .iter() - .map(|claim| { - Ok(format!( - " Stage5SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {} }},", - rust_str(&claim.symbol), - rust_str(&claim.stage), - rust_str(&claim.domain), - claim.num_rounds, - claim.degree, - rust_str(&claim.claim), - rust_option_str(claim.kernel.as_deref()), - super::plan_tokens::role_optional_relation_kind_expr( - "Stage5", - &self.role, - claim.relation.as_deref() - )?, - rust_str(&claim.claim_value) - )) - }) - .collect::, EmitError>>()? - .join("\n"); - return Ok(format!( - "pub const STAGE5_SUMCHECK_CLAIMS: &[Stage5SumcheckClaimPlan] = &[\n{claims}\n];\n" + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_claim_constants( + "Stage5", + "STAGE5", + &plan.claims, )); } @@ -1882,6 +2045,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_sumcheck_driver_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_driver_constants( + "Stage5", + "STAGE5", + &plan.drivers, + )); + } let mut source = String::new(); for (index, driver) in self.drivers.iter().enumerate() { source.push_str(&emit_usize_array( @@ -1940,6 +2111,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_sumcheck_instance_result_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_instance_result_constants( + "Stage5", + "STAGE5", + &plan.instance_results, + )); + } let instances = self .instance_results .iter() @@ -2078,6 +2257,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_opening_claim_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_claim_constants( + "Stage5", + "STAGE5", + &plan.opening_claims, + )); + } let claims = self .opening_claims .iter() @@ -2101,6 +2288,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_opening_claim_equality_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_claim_equality_constants( + "Stage5", + "STAGE5", + &plan.opening_equalities, + )); + } let equalities = self .opening_equalities .iter() diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index b50130e41d..30793f83ba 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -372,135 +372,52 @@ pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage5StructuredPolynomialEva Stage5StructuredPolynomialEvalPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.instruction_read_raf.point", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::YPoint, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.instruction.LookupOutput", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_8_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_8_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_9_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_9_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_10_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_10_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_11_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_11_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_12_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_12_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_13_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_13_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_14_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_14_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_15_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_15_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_16_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_16_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_17_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_17_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_18_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_18_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_19_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_19_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_20_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_20_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_21_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_21_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_22_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_22_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_23_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_23_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_24_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_24_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_25_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_25_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_26_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_26_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_27_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_27_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_28_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_28_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_29_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_29_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_30_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_30_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_31_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_31_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_32_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_32_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_33_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_33_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_34_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_34_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_35_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_35_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_36_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_36_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_37_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_37_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_38_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_38_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_39_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_39_FACTORS: &[&str] = &[]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_40_EVALS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_40_FACTORS: &[&str] = &[]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_1_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_2_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_3_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_4_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_5_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_6_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_7_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_8_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_8_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_9_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_9_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_10_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_10_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_11_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_11_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_12_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_12_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_13_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_13_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_14_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_14_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_15_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_15_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_16_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_16_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_17_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_17_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_18_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_18_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_19_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_19_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_20_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_20_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_21_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_21_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_22_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_22_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_23_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_23_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_24_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_24_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_25_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_25_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_26_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_26_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_27_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_27_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_28_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_28_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_29_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_29_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_30_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_30_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_31_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_31_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_32_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_32_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_33_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_33_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_34_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_34_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_35_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_35_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_36_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_36_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_37_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_37_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_38_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_38_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_39_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_39_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_40_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_40_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"], factors: &[] }, ]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_EVALS: &[&str] = &["stage5.instruction_read_raf.eval.InstructionRa_0", "stage5.instruction_read_raf.eval.InstructionRa_1", "stage5.instruction_read_raf.eval.InstructionRa_2", "stage5.instruction_read_raf.eval.InstructionRa_3", "stage5.instruction_read_raf.eval.InstructionRa_4", "stage5.instruction_read_raf.eval.InstructionRa_5", "stage5.instruction_read_raf.eval.InstructionRa_6", "stage5.instruction_read_raf.eval.InstructionRa_7"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_FACTORS: &[&str] = &[]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_EVALS, factors: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_EVALS, factors: &[] }, ]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.LookupTableValues", gamma: None, terms: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 802ab9d1d2..60f2f65c60 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -635,85 +635,46 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage6StructuredPolynomialEva Stage6StructuredPolynomialEvalPlan { symbol: "stage6.booleanity.output.eq.InstructionRa0", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.output.point", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_1_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_2_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_3_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_4_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_5_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_6_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_7_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_8_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_9_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_10_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_11_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_12_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_13_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_14_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_15_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_16_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_17_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_18_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_19_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_20_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_21_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_22_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_23_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_24_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_25_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_26_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_27_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_28_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_29_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_30_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_31_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_32_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_33_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_34_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_35_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_36_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_37_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_38_FACTORS: &[&str] = &["stage6.booleanity.output.eq.InstructionRa0"]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_0", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_0_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 2, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_1", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_1_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 4, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_2", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_2_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 6, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_3", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_3_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 8, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_4", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_4_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 10, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_5", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_5_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 12, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_6", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_6_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 14, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_7", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_7_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 16, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_8", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_8_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 18, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_9", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_9_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 20, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_10", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_10_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 22, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_11", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_11_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 24, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_12", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_12_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 26, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_13", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_13_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 28, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_14", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_14_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 30, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_15", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_15_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 32, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_16", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_16_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 34, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_17", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_17_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 36, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_18", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_18_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 38, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_19", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_19_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 40, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_20", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_20_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 42, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_21", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_21_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 44, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_22", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_22_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 46, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_23", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_23_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 48, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_24", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_24_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 50, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_25", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_25_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 52, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_26", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_26_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 54, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_27", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_27_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 56, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_28", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_28_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 58, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_29", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_29_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 60, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_30", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_30_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 62, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_31", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_31_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 64, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_0", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_32_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 66, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_1", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_33_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 68, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_2", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_34_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 70, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_0", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_35_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 72, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_1", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_36_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 74, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_2", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_37_FACTORS }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 76, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_3", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERM_38_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 2, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 4, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 6, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_3", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 8, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_4", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 10, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_5", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 12, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_6", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 14, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_7", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 16, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_8", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 18, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_9", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 20, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_10", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 22, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_11", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 24, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_12", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 26, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_13", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 28, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_14", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 30, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_15", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 32, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_16", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 34, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_17", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 36, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_18", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 38, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_19", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 40, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_20", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 42, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_21", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 44, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_22", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 46, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_23", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 48, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_24", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 50, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_25", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 52, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_26", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 54, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_27", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 56, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_28", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 58, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_29", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 60, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_30", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 62, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_31", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 64, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 66, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 68, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 70, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 72, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 74, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 76, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_3", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan] = &[ bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: "stage6.booleanity.output.family", gamma: Some("stage6.booleanity.gamma"), terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS }, @@ -723,9 +684,8 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage6StructuredPolynomialEva Stage6StructuredPolynomialEvalPlan { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.hamming_booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage1.LookupOutput", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.hamming_booleanity.output.eq.LookupOutput"]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.hamming_booleanity.eval.HammingWeight", factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILY_0_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.hamming_booleanity.eval.HammingWeight", factors: &["stage6.hamming_booleanity.output.eq.LookupOutput"] }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan] = &[ bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: "stage6.hamming_booleanity.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILY_0_TERMS }, @@ -735,10 +695,8 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage6StructuredPolynomialEva Stage6StructuredPolynomialEvalPlan { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.ram_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.ram_ra_virtual.output.eq.Cycle"]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"], factors: &["stage6.ram_ra_virtual.output.eq.Cycle"] }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, @@ -748,31 +706,15 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES: &[Stage6StructuredPolynomialEva Stage6StructuredPolynomialEvalPlan { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.instruction_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_1_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_1_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_2_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_2_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_3_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_3_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_4_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_4_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_5_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_5_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_6_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_6_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_7_EVALS: &[&str] = &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_7_FACTORS: &[&str] = &["stage6.instruction_ra_virtual.output.eq.Cycle"]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_0_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_1_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_1_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_2_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_2_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 3, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_3_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_3_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 4, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_4_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_4_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 5, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_5_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_5_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 6, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_6_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_6_FACTORS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_7_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERM_7_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 3, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 4, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 5, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 6, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: Some("stage6.instruction_ra_virtual.gamma"), terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERMS }, @@ -786,28 +728,23 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_VALUES: &[Stage6StructuredPolynomialEva ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_EVALS: &[&str] = &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.eval.RdInc"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_VALUE_TERM_OFFSETS: &[usize] = &[]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan] = &[ ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERM_0_FACTORS: &[&str] = &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERM_1_FACTORS: &[&str] = &["stage6.inc_claim_reduction.output.eq.RamIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 0, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERM_0_FACTORS }, - bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 1, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERM_1_FACTORS }, + bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 0, factors: &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"] }, + bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 1, factors: &["stage6.inc_claim_reduction.output.eq.RamIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage5"] }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage6.inc_claim_reduction.output.family", gamma: "stage6.inc_claim_reduction.gamma", evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_EVALS, power_stride: 2, value_term_offsets: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_VALUE_TERM_OFFSETS, shared_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_SHARED_TERMS, item_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERMS }, + bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage6.inc_claim_reduction.output.family", gamma: "stage6.inc_claim_reduction.gamma", evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_EVALS, power_stride: 2, value_term_offsets: &[], shared_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_SHARED_TERMS, item_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERMS }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERM_0_EVALS: &[&str] = &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERM_0_FACTORS: &[&str] = &[]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERM_0_EVALS, factors: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERM_0_FACTORS }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"], factors: &[] }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERMS }, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 4a9bcce3c5..b08108e1a6 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -275,7 +275,6 @@ pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage7StructuredPolynomialEva ]; pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_EVALS: &[&str] = &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3"]; -pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_VALUE_TERM_OFFSETS: &[usize] = &[0]; pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan] = &[ bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan { gamma_power_offset: 1, factor: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity" }, ]; @@ -284,7 +283,7 @@ pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERMS: &[bolt_verifier_ru bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 2, factors: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERM_0_FACTORS }, ]; pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage7.hamming_weight_claim_reduction.output.family", gamma: "stage7.hamming_weight_claim_reduction.gamma", evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_EVALS, power_stride: 3, value_term_offsets: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_VALUE_TERM_OFFSETS, shared_terms: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_SHARED_TERMS, item_terms: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERMS }, + bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage7.hamming_weight_claim_reduction.output.family", gamma: "stage7.hamming_weight_claim_reduction.gamma", evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_EVALS, power_stride: 3, value_term_offsets: &[0], shared_terms: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_SHARED_TERMS, item_terms: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERMS }, ]; pub const STAGE7_SUMCHECK_OUTPUT_CLAIMS: &[Stage7SumcheckOutputClaimPlan] = &[ From 69ab4f415bb207ecb8da43c015fb873fb7f1d9a2 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 08:03:56 -0600 Subject: [PATCH 079/171] refactor(bolt): share verifier batch plans Model verifier sumcheck batches, point derivations, and opening batches in the shared verifier-stage plan. Route Stage 5 verifier emission through that plan while preserving generated verifier output. --- .../src/protocols/jolt/emit/rust/stage3.rs | 49 +++++ .../src/protocols/jolt/emit/rust/stage4.rs | 49 +++++ .../src/protocols/jolt/emit/rust/stage5.rs | 171 +++++++++--------- .../bolt/src/protocols/jolt/verifier_plan.rs | 155 ++++++++++++++++ 4 files changed, 342 insertions(+), 82 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index ec1ef207f0..39e177320f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -672,6 +672,21 @@ impl Stage3CpuProgram { }) }) .collect::, EmitError>>()?, + batches: self + .batches + .iter() + .map(|batch| verifier_plan::VerifierSumcheckBatchPlan { + symbol: batch.symbol.clone(), + stage: batch.stage.clone(), + proof_slot: batch.proof_slot.clone(), + policy: batch.policy.clone(), + count: batch.count, + claim_operands: batch.claim_operands.clone(), + claim_label: batch.claim_label.clone(), + round_label: batch.round_label.clone(), + round_schedule: batch.round_schedule.clone(), + }) + .collect(), drivers: self .drivers .iter() @@ -715,6 +730,27 @@ impl Stage3CpuProgram { }) }) .collect::, EmitError>>()?, + point_slices: self + .point_slices + .iter() + .map(|slice| verifier_plan::VerifierPointSlicePlan { + symbol: slice.symbol.clone(), + source: slice.source.clone(), + offset: slice.offset, + length: slice.length, + input: slice.input.clone(), + }) + .collect(), + point_concats: self + .point_concats + .iter() + .map(|concat| verifier_plan::VerifierPointConcatPlan { + symbol: concat.symbol.clone(), + layout: concat.layout.clone(), + arity: concat.arity, + inputs: concat.inputs.clone(), + }) + .collect(), opening_claims: self .opening_claims .iter() @@ -742,6 +778,19 @@ impl Stage3CpuProgram { }) }) .collect::, EmitError>>()?, + opening_batches: self + .opening_batches + .iter() + .map(|batch| verifier_plan::VerifierOpeningBatchPlan { + symbol: batch.symbol.clone(), + stage: batch.stage.clone(), + proof_slot: batch.proof_slot.clone(), + policy: batch.policy.clone(), + count: batch.count, + ordered_claims: batch.ordered_claims.clone(), + claim_operands: batch.claim_operands.clone(), + }) + .collect(), }) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index b82ce0dc0b..4f5e6bd89e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -694,6 +694,21 @@ impl Stage4CpuProgram { }) }) .collect::, EmitError>>()?, + batches: self + .batches + .iter() + .map(|batch| verifier_plan::VerifierSumcheckBatchPlan { + symbol: batch.symbol.clone(), + stage: batch.stage.clone(), + proof_slot: batch.proof_slot.clone(), + policy: batch.policy.clone(), + count: batch.count, + claim_operands: batch.claim_operands.clone(), + claim_label: batch.claim_label.clone(), + round_label: batch.round_label.clone(), + round_schedule: batch.round_schedule.clone(), + }) + .collect(), drivers: self .drivers .iter() @@ -737,6 +752,27 @@ impl Stage4CpuProgram { }) }) .collect::, EmitError>>()?, + point_slices: self + .point_slices + .iter() + .map(|slice| verifier_plan::VerifierPointSlicePlan { + symbol: slice.symbol.clone(), + source: slice.source.clone(), + offset: slice.offset, + length: slice.length, + input: slice.input.clone(), + }) + .collect(), + point_concats: self + .point_concats + .iter() + .map(|concat| verifier_plan::VerifierPointConcatPlan { + symbol: concat.symbol.clone(), + layout: concat.layout.clone(), + arity: concat.arity, + inputs: concat.inputs.clone(), + }) + .collect(), opening_claims: self .opening_claims .iter() @@ -764,6 +800,19 @@ impl Stage4CpuProgram { }) }) .collect::, EmitError>>()?, + opening_batches: self + .opening_batches + .iter() + .map(|batch| verifier_plan::VerifierOpeningBatchPlan { + symbol: batch.symbol.clone(), + stage: batch.stage.clone(), + proof_slot: batch.proof_slot.clone(), + policy: batch.policy.clone(), + count: batch.count, + ordered_claims: batch.ordered_claims.clone(), + claim_operands: batch.claim_operands.clone(), + }) + .collect(), }) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 503ea277a3..8246fce80b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -745,6 +745,21 @@ impl Stage5CpuProgram { }) }) .collect::, EmitError>>()?, + batches: self + .batches + .iter() + .map(|batch| verifier_plan::VerifierSumcheckBatchPlan { + symbol: batch.symbol.clone(), + stage: batch.stage.clone(), + proof_slot: batch.proof_slot.clone(), + policy: batch.policy.clone(), + count: batch.count, + claim_operands: batch.claim_operands.clone(), + claim_label: batch.claim_label.clone(), + round_label: batch.round_label.clone(), + round_schedule: batch.round_schedule.clone(), + }) + .collect(), drivers: self .drivers .iter() @@ -788,6 +803,27 @@ impl Stage5CpuProgram { }) }) .collect::, EmitError>>()?, + point_slices: self + .point_slices + .iter() + .map(|slice| verifier_plan::VerifierPointSlicePlan { + symbol: slice.symbol.clone(), + source: slice.source.clone(), + offset: slice.offset, + length: slice.length, + input: slice.input.clone(), + }) + .collect(), + point_concats: self + .point_concats + .iter() + .map(|concat| verifier_plan::VerifierPointConcatPlan { + symbol: concat.symbol.clone(), + layout: concat.layout.clone(), + arity: concat.arity, + inputs: concat.inputs.clone(), + }) + .collect(), opening_claims: self .opening_claims .iter() @@ -815,6 +851,19 @@ impl Stage5CpuProgram { }) }) .collect::, EmitError>>()?, + opening_batches: self + .opening_batches + .iter() + .map(|batch| verifier_plan::VerifierOpeningBatchPlan { + symbol: batch.symbol.clone(), + stage: batch.stage.clone(), + proof_slot: batch.proof_slot.clone(), + policy: batch.policy.clone(), + count: batch.count, + ordered_claims: batch.ordered_claims.clone(), + claim_operands: batch.claim_operands.clone(), + }) + .collect(), }) } @@ -1648,7 +1697,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_kernel_constants()); source.push_str(&self.emit_sumcheck_claim_constants()?); - source.push_str(&self.emit_sumcheck_batch_constants()); + source.push_str(&self.emit_sumcheck_batch_constants()?); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); if self.role == Role::Verifier { @@ -1965,41 +2014,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); Ok(source) } - fn emit_sumcheck_batch_constants(&self) -> String { + fn emit_sumcheck_batch_constants(&self) -> Result { if self.role == Role::Verifier { - let mut source = String::new(); - for (index, batch) in self.batches.iter().enumerate() { - source.push_str(&emit_usize_array( - &format!("STAGE5_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"), - &batch.round_schedule, - )); - } - let batches = self - .batches - .iter() - .enumerate() - .map(|(index, batch)| { - format!( - " Stage5SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: STAGE5_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", - rust_str(&batch.symbol), - rust_str(&batch.stage), - rust_str(&batch.proof_slot), - rust_str(&batch.policy), - batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.claim_operands), - rust_str(&batch.claim_label), - rust_str(&batch.round_label) - ) - }) - .collect::>() - .join("\n"); - push_format( - &mut source, - format_args!( - "pub const STAGE5_SUMCHECK_BATCHES: &[Stage5SumcheckBatchPlan] = &[\n{batches}\n];\n" - ), - ); - return source; + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_batch_constants( + "Stage5", + "STAGE5", + &plan.batches, + )); } let mut source = String::new(); @@ -2041,7 +2063,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); "pub const STAGE5_SUMCHECK_BATCHES: &[Stage5SumcheckBatchPlan] = &[\n{batches}\n];\n" ), ); - source + Ok(source) } fn emit_sumcheck_driver_constants(&self) -> Result { @@ -2102,11 +2124,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); if self.role == Role::Verifier { source.push_str(&self.emit_named_eval_family_constants()?); } - source.push_str(&self.emit_point_slice_constants()); - source.push_str(&self.emit_point_concat_constants()); + source.push_str(&self.emit_point_slice_constants()?); + source.push_str(&self.emit_point_concat_constants()?); source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_claim_equality_constants()?); - source.push_str(&self.emit_opening_batch_constants()); + source.push_str(&self.emit_opening_batch_constants()?); Ok(source) } @@ -2186,7 +2208,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); ) } - fn emit_point_slice_constants(&self) -> String { + fn emit_point_slice_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_point_slice_constants( + "Stage5", + "STAGE5", + &plan.point_slices, + )); + } let slices = self .point_slices .iter() @@ -2202,28 +2232,19 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); }) .collect::>() .join("\n"); - format!("pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[\n{slices}\n];\n\n") + Ok(format!( + "pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[\n{slices}\n];\n\n" + )) } - fn emit_point_concat_constants(&self) -> String { + fn emit_point_concat_constants(&self) -> Result { if self.role == Role::Verifier { - let concats = self - .point_concats - .iter() - .map(|concat| { - format!( - " Stage5PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},", - rust_str(&concat.symbol), - rust_str(&concat.layout), - concat.arity, - super::plan_tokens::rust_str_slice_expr(&concat.inputs) - ) - }) - .collect::>() - .join("\n"); - return format!( - "pub const STAGE5_POINT_CONCATS: &[Stage5PointConcatPlan] = &[\n{concats}\n];\n" - ); + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_point_concat_constants( + "Stage5", + "STAGE5", + &plan.point_concats, + )); } let mut source = String::new(); @@ -2253,7 +2274,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); "pub const STAGE5_POINT_CONCATS: &[Stage5PointConcatPlan] = &[\n{concats}\n];\n" ), ); - source + Ok(source) } fn emit_opening_claim_constants(&self) -> Result { @@ -2315,28 +2336,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); )) } - fn emit_opening_batch_constants(&self) -> String { + fn emit_opening_batch_constants(&self) -> Result { if self.role == Role::Verifier { - let batches = self - .opening_batches - .iter() - .map(|batch| { - format!( - " Stage5OpeningBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {} }},", - rust_str(&batch.symbol), - rust_str(&batch.stage), - rust_str(&batch.proof_slot), - rust_str(&batch.policy), - batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), - super::plan_tokens::rust_str_slice_expr(&batch.claim_operands) - ) - }) - .collect::>() - .join("\n"); - return format!( - "pub const STAGE5_OPENING_BATCHES: &[Stage5OpeningBatchPlan] = &[\n{batches}\n];\n" - ); + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_batch_constants( + "Stage5", + "STAGE5", + &plan.opening_batches, + )); } let mut source = String::new(); @@ -2372,7 +2379,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); "pub const STAGE5_OPENING_BATCHES: &[Stage5OpeningBatchPlan] = &[\n{batches}\n];\n" ), ); - source + Ok(source) } fn emit_entrypoint(&self) -> &'static str { diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 33b1544d25..9d41ea222e 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -128,6 +128,19 @@ pub(crate) struct VerifierSumcheckClaimPlan { pub(crate) claim_value: String, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierSumcheckBatchPlan { + pub(crate) symbol: String, + pub(crate) stage: String, + pub(crate) proof_slot: String, + pub(crate) policy: String, + pub(crate) count: usize, + pub(crate) claim_operands: Vec, + pub(crate) claim_label: String, + pub(crate) round_label: String, + pub(crate) round_schedule: Vec, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierSumcheckDriverPlan { pub(crate) symbol: String, @@ -157,6 +170,23 @@ pub(crate) struct VerifierSumcheckInstanceResultPlan { pub(crate) degree: usize, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierPointSlicePlan { + pub(crate) symbol: String, + pub(crate) source: String, + pub(crate) offset: usize, + pub(crate) length: usize, + pub(crate) input: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierPointConcatPlan { + pub(crate) symbol: String, + pub(crate) layout: String, + pub(crate) arity: usize, + pub(crate) inputs: Vec, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierOpeningClaimPlan { pub(crate) symbol: String, @@ -176,6 +206,17 @@ pub(crate) struct VerifierOpeningClaimEqualityPlan { pub(crate) rhs: String, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierOpeningBatchPlan { + pub(crate) symbol: String, + pub(crate) stage: String, + pub(crate) proof_slot: String, + pub(crate) policy: String, + pub(crate) count: usize, + pub(crate) ordered_claims: Vec, + pub(crate) claim_operands: Vec, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierStagePlan { pub(crate) steps: Vec, @@ -184,10 +225,14 @@ pub(crate) struct VerifierStagePlan { pub(crate) opening_inputs: Vec, pub(crate) field_exprs: Vec, pub(crate) claims: Vec, + pub(crate) batches: Vec, pub(crate) drivers: Vec, pub(crate) instance_results: Vec, + pub(crate) point_slices: Vec, + pub(crate) point_concats: Vec, pub(crate) opening_claims: Vec, pub(crate) opening_equalities: Vec, + pub(crate) opening_batches: Vec, } pub(crate) fn relation_from_cpu(value: &str) -> Result { @@ -414,6 +459,43 @@ pub(crate) fn emit_sumcheck_claim_constants( ) } +pub(crate) fn emit_sumcheck_batch_constants( + stage_type_prefix: &str, + const_prefix: &str, + batches: &[VerifierSumcheckBatchPlan], +) -> String { + let mut source = String::new(); + for (index, batch) in batches.iter().enumerate() { + source.push_str(&emit_usize_array( + &format!("{const_prefix}_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"), + &batch.round_schedule, + )); + } + let batches = batches + .iter() + .enumerate() + .map(|(index, batch)| { + format!( + " {stage_type_prefix}SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: {const_prefix}_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", + rust_str(&batch.symbol), + rust_str(&batch.stage), + rust_str(&batch.proof_slot), + rust_str(&batch.policy), + batch.count, + rust_str_slice_expr(&batch.claim_operands), + rust_str(&batch.claim_label), + rust_str(&batch.round_label) + ) + }) + .collect::>() + .join("\n"); + let _ = write!( + source, + "pub const {const_prefix}_SUMCHECK_BATCHES: &[{stage_type_prefix}SumcheckBatchPlan] = &[\n{batches}\n];\n" + ); + source +} + pub(crate) fn emit_sumcheck_driver_constants( stage_type_prefix: &str, const_prefix: &str, @@ -482,6 +564,53 @@ pub(crate) fn emit_sumcheck_instance_result_constants( ) } +pub(crate) fn emit_point_slice_constants( + stage_type_prefix: &str, + const_prefix: &str, + slices: &[VerifierPointSlicePlan], +) -> String { + let slices = slices + .iter() + .map(|slice| { + format!( + " {stage_type_prefix}PointSlicePlan {{ symbol: {}, source: {}, offset: {}, length: {}, input: {} }},", + rust_str(&slice.symbol), + rust_str(&slice.source), + slice.offset, + slice.length, + rust_str(&slice.input) + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_POINT_SLICES: &[{stage_type_prefix}PointSlicePlan] = &[\n{slices}\n];\n\n" + ) +} + +pub(crate) fn emit_point_concat_constants( + stage_type_prefix: &str, + const_prefix: &str, + concats: &[VerifierPointConcatPlan], +) -> String { + let concats = concats + .iter() + .map(|concat| { + format!( + " {stage_type_prefix}PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},", + rust_str(&concat.symbol), + rust_str(&concat.layout), + concat.arity, + rust_str_slice_expr(&concat.inputs) + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_POINT_CONCATS: &[{stage_type_prefix}PointConcatPlan] = &[\n{concats}\n];\n" + ) +} + pub(crate) fn emit_opening_claim_constants( stage_type_prefix: &str, const_prefix: &str, @@ -531,6 +660,32 @@ pub(crate) fn emit_opening_claim_equality_constants( ) } +pub(crate) fn emit_opening_batch_constants( + stage_type_prefix: &str, + const_prefix: &str, + batches: &[VerifierOpeningBatchPlan], +) -> String { + let batches = batches + .iter() + .map(|batch| { + format!( + " {stage_type_prefix}OpeningBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {} }},", + rust_str(&batch.symbol), + rust_str(&batch.stage), + rust_str(&batch.proof_slot), + rust_str(&batch.policy), + batch.count, + rust_str_slice_expr(&batch.ordered_claims), + rust_str_slice_expr(&batch.claim_operands) + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_OPENING_BATCHES: &[{stage_type_prefix}OpeningBatchPlan] = &[\n{batches}\n];\n" + ) +} + fn emit_usize_array(name: &str, values: &[usize]) -> String { let entries = values .iter() From fda289409661d48773bd640a8516dbec3e387192 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 08:14:05 -0600 Subject: [PATCH 080/171] refactor(bolt): plan stage6 verifier emission Add point-zero support to the shared verifier-stage plan and route Stage 6 verifier constants through typed plan data while preserving generated verifier output. --- .../src/protocols/jolt/emit/rust/stage3.rs | 1 + .../src/protocols/jolt/emit/rust/stage4.rs | 1 + .../src/protocols/jolt/emit/rust/stage5.rs | 1 + .../src/protocols/jolt/emit/rust/stage6.rs | 501 +++++++++++++----- .../bolt/src/protocols/jolt/verifier_plan.rs | 101 +++- 5 files changed, 460 insertions(+), 145 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 39e177320f..ddf9063934 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -730,6 +730,7 @@ impl Stage3CpuProgram { }) }) .collect::, EmitError>>()?, + point_zeros: Vec::new(), point_slices: self .point_slices .iter() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 4f5e6bd89e..e2ad405fd7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -752,6 +752,7 @@ impl Stage4CpuProgram { }) }) .collect::, EmitError>>()?, + point_zeros: Vec::new(), point_slices: self .point_slices .iter() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 8246fce80b..b106ebc2d0 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -803,6 +803,7 @@ impl Stage5CpuProgram { }) }) .collect::, EmitError>>()?, + point_zeros: Vec::new(), point_slices: self .point_slices .iter() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index eea1fdd044..faeb07f3c1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -25,6 +25,7 @@ use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputFunctionFamilyPlan as Stage6SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan as Stage6SumcheckOutputProductFamilyPlan, }; +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::schema::verify_cpu_schema; use super::plan_tokens::{ @@ -57,6 +58,7 @@ const STAGE6_KERNEL_ABIS: &[(&str, &str)] = &[ #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage6CpuProgram { pub role: Role, + pub(crate) verifier_plan: Option, pub params: Stage6Params, pub steps: Vec, pub transcript_squeezes: Vec, @@ -625,6 +627,7 @@ impl Stage6CpuProgram { let role = module .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; + let is_verifier = role == Role::Verifier; if role == Role::Prover { verifier_output_claims::prune_output_only_field_exprs( &mut field_exprs, @@ -651,9 +654,10 @@ impl Stage6CpuProgram { output_claims.push(stage6_bytecode_read_raf_output_claim_plan()); } - Ok(Self { + let mut program = Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, role, + verifier_plan: None, steps, transcript_squeezes, transcript_absorb_bytes, @@ -677,9 +681,228 @@ impl Stage6CpuProgram { opening_claims, opening_equalities, opening_batches, + }; + if is_verifier { + program.verifier_plan = Some(program.plan_verifier()?); + } + Ok(program) + } + + fn plan_verifier(&self) -> Result { + Ok(VerifierStagePlan { + steps: self + .steps + .iter() + .map(|step| { + verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) + }) + .collect::, EmitError>>()?, + transcript_squeezes: self + .transcript_squeezes + .iter() + .map(|squeeze| { + verifier_plan::VerifierTranscriptSqueezePlan::from_cpu( + &squeeze.symbol, + &squeeze.label, + &squeeze.kind, + squeeze.count, + ) + }) + .collect::, EmitError>>()?, + transcript_absorb_bytes: self + .transcript_absorb_bytes + .iter() + .map(|absorb| { + verifier_plan::VerifierTranscriptAbsorbBytesPlan::from_cpu( + &absorb.symbol, + &absorb.label, + &absorb.payload, + ) + }) + .collect(), + opening_inputs: self + .opening_inputs + .iter() + .map(|input| { + verifier_plan::VerifierOpeningInputPlan::from_cpu( + &input.symbol, + &input.source_stage, + &input.source_claim, + &input.oracle, + &input.domain, + input.point_arity, + &input.claim_kind, + ) + }) + .collect::, EmitError>>()?, + field_exprs: self + .field_exprs + .iter() + .map(|expr| { + verifier_plan::VerifierFieldExprPlan::from_cpu( + &expr.symbol, + &expr.formula, + &expr.operands, + ) + }) + .collect::, EmitError>>()?, + claims: self + .claims + .iter() + .map(|claim| { + Ok(verifier_plan::VerifierSumcheckClaimPlan { + symbol: claim.symbol.clone(), + stage: claim.stage.clone(), + domain: claim.domain.clone(), + num_rounds: claim.num_rounds, + degree: claim.degree, + claim: claim.claim.clone(), + relation: verifier_plan::required_relation_from_cpu( + claim.relation.as_deref(), + "claim", + &claim.symbol, + )?, + claim_value: claim.claim_value.clone(), + }) + }) + .collect::, EmitError>>()?, + batches: self + .batches + .iter() + .map(|batch| verifier_plan::VerifierSumcheckBatchPlan { + symbol: batch.symbol.clone(), + stage: batch.stage.clone(), + proof_slot: batch.proof_slot.clone(), + policy: batch.policy.clone(), + count: batch.count, + claim_operands: batch.claim_operands.clone(), + claim_label: batch.claim_label.clone(), + round_label: batch.round_label.clone(), + round_schedule: batch.round_schedule.clone(), + }) + .collect(), + drivers: self + .drivers + .iter() + .map(|driver| { + Ok(verifier_plan::VerifierSumcheckDriverPlan { + symbol: driver.symbol.clone(), + stage: driver.stage.clone(), + proof_slot: driver.proof_slot.clone(), + relation: verifier_plan::required_relation_from_cpu( + driver.relation.as_deref(), + "driver", + &driver.symbol, + )?, + batch: driver.batch.clone(), + policy: driver.policy.clone(), + round_schedule: driver.round_schedule.clone(), + claim_label: driver.claim_label.clone(), + round_label: driver.round_label.clone(), + num_rounds: driver.num_rounds, + degree: driver.degree, + }) + }) + .collect::, EmitError>>()?, + instance_results: self + .instance_results + .iter() + .map(|instance| { + Ok(verifier_plan::VerifierSumcheckInstanceResultPlan { + symbol: instance.symbol.clone(), + source: instance.source.clone(), + claim: instance.claim.clone(), + relation: verifier_plan::relation_from_cpu(&instance.relation)?, + index: instance.index, + point_arity: instance.point_arity, + num_rounds: instance.num_rounds, + round_offset: instance.round_offset, + point_order: verifier_plan::sumcheck_point_order_from_cpu( + &instance.point_order, + )?, + degree: instance.degree, + }) + }) + .collect::, EmitError>>()?, + point_zeros: self + .point_zeros + .iter() + .map(|zero| verifier_plan::VerifierPointZeroPlan { + symbol: zero.symbol.clone(), + field: zero.field.clone(), + arity: zero.arity, + }) + .collect(), + point_slices: self + .point_slices + .iter() + .map(|slice| verifier_plan::VerifierPointSlicePlan { + symbol: slice.symbol.clone(), + source: slice.source.clone(), + offset: slice.offset, + length: slice.length, + input: slice.input.clone(), + }) + .collect(), + point_concats: self + .point_concats + .iter() + .map(|concat| verifier_plan::VerifierPointConcatPlan { + symbol: concat.symbol.clone(), + layout: concat.layout.clone(), + arity: concat.arity, + inputs: concat.inputs.clone(), + }) + .collect(), + opening_claims: self + .opening_claims + .iter() + .map(|claim| { + Ok(verifier_plan::VerifierOpeningClaimPlan { + symbol: claim.symbol.clone(), + oracle: claim.oracle.clone(), + domain: claim.domain.clone(), + point_arity: claim.point_arity, + claim_kind: verifier_plan::claim_kind_from_cpu(&claim.claim_kind)?, + point_source: claim.point_source.clone(), + eval_source: claim.eval_source.clone(), + }) + }) + .collect::, EmitError>>()?, + opening_equalities: self + .opening_equalities + .iter() + .map(|equality| { + Ok(verifier_plan::VerifierOpeningClaimEqualityPlan { + symbol: equality.symbol.clone(), + mode: verifier_plan::opening_equality_mode_from_cpu(&equality.mode)?, + lhs: equality.lhs.clone(), + rhs: equality.rhs.clone(), + }) + }) + .collect::, EmitError>>()?, + opening_batches: self + .opening_batches + .iter() + .map(|batch| verifier_plan::VerifierOpeningBatchPlan { + symbol: batch.symbol.clone(), + stage: batch.stage.clone(), + proof_slot: batch.proof_slot.clone(), + policy: batch.policy.clone(), + count: batch.count, + ordered_claims: batch.ordered_claims.clone(), + claim_operands: batch.claim_operands.clone(), + }) + .collect(), }) } + fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { + self.verifier_plan + .as_ref() + .ok_or_else(|| EmitError::new("missing stage6 verifier plan")) + } + fn verify_supported_target(&self) -> Result<(), EmitError> { require_supported_symbol("field", &self.params.field, "bn254_fr")?; require_supported_symbol("pcs", &self.params.pcs, "dory")?; @@ -1571,7 +1794,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_kernel_constants()); source.push_str(&self.emit_sumcheck_claim_constants()?); - source.push_str(&self.emit_sumcheck_batch_constants()); + source.push_str(&self.emit_sumcheck_batch_constants()?); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); if self.role == Role::Verifier { @@ -1628,7 +1851,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); ); source.push_str(&self.emit_program_step_constants()?); source.push_str(&self.emit_transcript_squeeze_constants()?); - source.push_str(&self.emit_transcript_absorb_bytes_constants()); + source.push_str(&self.emit_transcript_absorb_bytes_constants()?); source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); @@ -1636,6 +1859,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); } fn emit_program_step_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_program_step_constants( + "Stage6", + "STAGE6", + &plan.steps, + )); + } let steps = self .steps .iter() @@ -1656,6 +1887,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); } fn emit_transcript_squeeze_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_transcript_squeeze_constants( + "Stage6", + "STAGE6", + &plan.transcript_squeezes, + )); + } let squeezes = self .transcript_squeezes .iter() @@ -1675,7 +1914,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); )) } - fn emit_transcript_absorb_bytes_constants(&self) -> String { + fn emit_transcript_absorb_bytes_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_transcript_absorb_bytes_constants( + "Stage6", + "STAGE6", + &plan.transcript_absorb_bytes, + )); + } let absorbs = self .transcript_absorb_bytes .iter() @@ -1689,12 +1936,20 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); }) .collect::>() .join("\n"); - format!( + Ok(format!( "pub const STAGE6_TRANSCRIPT_ABSORB_BYTES: &[Stage6TranscriptAbsorbBytesPlan] = &[\n{absorbs}\n];\n\n" - ) + )) } fn emit_opening_input_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_input_constants( + "Stage6", + "STAGE6", + &plan.opening_inputs, + )); + } let inputs = self .opening_inputs .iter() @@ -1738,32 +1993,13 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { - let rows = self - .field_exprs - .chunks(8) - .map(|chunk| { - let exprs = chunk - .iter() - .map(|expr| { - Ok(format!( - "stage6_field_expr({}, {}, {})", - rust_str(&expr.symbol), - super::plan_tokens::role_field_expr_kind_expr( - "Stage6", - &self.role, - &expr.formula - )?, - super::plan_tokens::rust_str_slice_expr(&expr.operands) - )) - }) - .collect::, EmitError>>()? - .join(", "); - Ok(format!(" {exprs},")) - }) - .collect::, EmitError>>()? - .join("\n"); - return Ok(format!( - "const fn stage6_field_expr(symbol: &'static str, kind: Stage6FieldExprKind, operands: &'static [&'static str]) -> Stage6FieldExprPlan {{\n Stage6FieldExprPlan {{ symbol, kind, operands }}\n}}\n\n#[rustfmt::skip]\npub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[\n{rows}\n];\n" + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_field_expr_constants_chunked( + "Stage6", + "STAGE6", + "stage6_field_expr", + &plan.field_exprs, + 8, )); } @@ -1830,31 +2066,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); fn emit_sumcheck_claim_constants(&self) -> Result { if self.role == Role::Verifier { - let claims = self - .claims - .iter() - .map(|claim| { - Ok(format!( - " Stage6SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {} }},", - rust_str(&claim.symbol), - rust_str(&claim.stage), - rust_str(&claim.domain), - claim.num_rounds, - claim.degree, - rust_str(&claim.claim), - rust_option_str(claim.kernel.as_deref()), - super::plan_tokens::role_optional_relation_kind_expr( - "Stage6", - &self.role, - claim.relation.as_deref() - )?, - rust_str(&claim.claim_value) - )) - }) - .collect::, EmitError>>()? - .join("\n"); - return Ok(format!( - "pub const STAGE6_SUMCHECK_CLAIMS: &[Stage6SumcheckClaimPlan] = &[\n{claims}\n];\n" + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_claim_constants( + "Stage6", + "STAGE6", + &plan.claims, )); } @@ -1898,44 +2114,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); Ok(source) } - fn emit_sumcheck_batch_constants(&self) -> String { + fn emit_sumcheck_batch_constants(&self) -> Result { if self.role == Role::Verifier { - let mut source = String::new(); - for (index, batch) in self.batches.iter().enumerate() { - source.push_str(&emit_str_array( - &format!("STAGE6_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS"), - &batch.claim_operands, - )); - source.push_str(&emit_usize_array( - &format!("STAGE6_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"), - &batch.round_schedule, - )); - } - let batches = self - .batches - .iter() - .enumerate() - .map(|(index, batch)| { - format!( - " Stage6SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: STAGE6_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS, claim_label: {}, round_label: {}, round_schedule: STAGE6_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", - rust_str(&batch.symbol), - rust_str(&batch.stage), - rust_str(&batch.proof_slot), - rust_str(&batch.policy), - batch.count, - rust_str(&batch.claim_label), - rust_str(&batch.round_label) - ) - }) - .collect::>() - .join("\n"); - push_format( - &mut source, - format_args!( - "pub const STAGE6_SUMCHECK_BATCHES: &[Stage6SumcheckBatchPlan] = &[\n{batches}\n];\n" - ), - ); - return source; + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_batch_constants( + "Stage6", + "STAGE6", + &plan.batches, + )); } let mut source = String::new(); @@ -1977,10 +2163,18 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); "pub const STAGE6_SUMCHECK_BATCHES: &[Stage6SumcheckBatchPlan] = &[\n{batches}\n];\n" ), ); - source + Ok(source) } fn emit_sumcheck_driver_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_driver_constants( + "Stage6", + "STAGE6", + &plan.drivers, + )); + } let mut source = String::new(); for (index, driver) in self.drivers.iter().enumerate() { source.push_str(&emit_usize_array( @@ -2027,16 +2221,24 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); let mut source = String::new(); source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); - source.push_str(&self.emit_point_zero_constants()); - source.push_str(&self.emit_point_slice_constants()); - source.push_str(&self.emit_point_concat_constants()); + source.push_str(&self.emit_point_zero_constants()?); + source.push_str(&self.emit_point_slice_constants()?); + source.push_str(&self.emit_point_concat_constants()?); source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_claim_equality_constants()?); - source.push_str(&self.emit_opening_batch_constants()); + source.push_str(&self.emit_opening_batch_constants()?); Ok(source) } fn emit_sumcheck_instance_result_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_instance_result_constants( + "Stage6", + "STAGE6", + &plan.instance_results, + )); + } let instances = self .instance_results .iter() @@ -2105,7 +2307,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); ) } - fn emit_point_zero_constants(&self) -> String { + fn emit_point_zero_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_point_zero_constants( + "Stage6", + "STAGE6", + &plan.point_zeros, + )); + } let zeros = self .point_zeros .iter() @@ -2119,10 +2329,20 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); }) .collect::>() .join("\n"); - format!("pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[\n{zeros}\n];\n\n") + Ok(format!( + "pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[\n{zeros}\n];\n\n" + )) } - fn emit_point_slice_constants(&self) -> String { + fn emit_point_slice_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_point_slice_constants( + "Stage6", + "STAGE6", + &plan.point_slices, + )); + } let slices = self .point_slices .iter() @@ -2138,28 +2358,19 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); }) .collect::>() .join("\n"); - format!("pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[\n{slices}\n];\n\n") + Ok(format!( + "pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[\n{slices}\n];\n\n" + )) } - fn emit_point_concat_constants(&self) -> String { + fn emit_point_concat_constants(&self) -> Result { if self.role == Role::Verifier { - let concats = self - .point_concats - .iter() - .map(|concat| { - format!( - " Stage6PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},", - rust_str(&concat.symbol), - rust_str(&concat.layout), - concat.arity, - super::plan_tokens::rust_str_slice_expr(&concat.inputs) - ) - }) - .collect::>() - .join("\n"); - return format!( - "pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[\n{concats}\n];\n" - ); + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_point_concat_constants( + "Stage6", + "STAGE6", + &plan.point_concats, + )); } let mut source = String::new(); @@ -2189,10 +2400,18 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); "pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[\n{concats}\n];\n" ), ); - source + Ok(source) } fn emit_opening_claim_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_claim_constants( + "Stage6", + "STAGE6", + &plan.opening_claims, + )); + } let claims = self .opening_claims .iter() @@ -2216,6 +2435,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); } fn emit_opening_claim_equality_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_claim_equality_constants( + "Stage6", + "STAGE6", + &plan.opening_equalities, + )); + } let equalities = self .opening_equalities .iter() @@ -2235,28 +2462,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); )) } - fn emit_opening_batch_constants(&self) -> String { + fn emit_opening_batch_constants(&self) -> Result { if self.role == Role::Verifier { - let batches = self - .opening_batches - .iter() - .map(|batch| { - format!( - " Stage6OpeningBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {} }},", - rust_str(&batch.symbol), - rust_str(&batch.stage), - rust_str(&batch.proof_slot), - rust_str(&batch.policy), - batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), - super::plan_tokens::rust_str_slice_expr(&batch.claim_operands) - ) - }) - .collect::>() - .join("\n"); - return format!( - "pub const STAGE6_OPENING_BATCHES: &[Stage6OpeningBatchPlan] = &[\n{batches}\n];\n" - ); + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_batch_constants( + "Stage6", + "STAGE6", + &plan.opening_batches, + )); } let mut source = String::new(); @@ -2292,7 +2505,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); "pub const STAGE6_OPENING_BATCHES: &[Stage6OpeningBatchPlan] = &[\n{batches}\n];\n" ), ); - source + Ok(source) } fn emit_entrypoint(&self) -> &'static str { diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 9d41ea222e..1bb8d6bdca 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -170,6 +170,13 @@ pub(crate) struct VerifierSumcheckInstanceResultPlan { pub(crate) degree: usize, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierPointZeroPlan { + pub(crate) symbol: String, + pub(crate) field: String, + pub(crate) arity: usize, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierPointSlicePlan { pub(crate) symbol: String, @@ -228,6 +235,7 @@ pub(crate) struct VerifierStagePlan { pub(crate) batches: Vec, pub(crate) drivers: Vec, pub(crate) instance_results: Vec, + pub(crate) point_zeros: Vec, pub(crate) point_slices: Vec, pub(crate) point_concats: Vec, pub(crate) opening_claims: Vec, @@ -432,6 +440,37 @@ pub(crate) fn emit_field_expr_constants( ) } +pub(crate) fn emit_field_expr_constants_chunked( + stage_type_prefix: &str, + const_prefix: &str, + helper_name: &str, + exprs: &[VerifierFieldExprPlan], + chunk_size: usize, +) -> String { + let rows = exprs + .chunks(chunk_size) + .map(|chunk| { + let exprs = chunk + .iter() + .map(|expr| { + format!( + "{helper_name}({}, {}, {})", + rust_str(&expr.symbol), + field_expr_kind_expr(stage_type_prefix, expr.kind), + rust_str_slice_expr(&expr.operands) + ) + }) + .collect::>() + .join(", "); + format!(" {exprs},") + }) + .collect::>() + .join("\n"); + format!( + "const fn {helper_name}(symbol: &'static str, kind: {stage_type_prefix}FieldExprKind, operands: &'static [&'static str]) -> {stage_type_prefix}FieldExprPlan {{\n {stage_type_prefix}FieldExprPlan {{ symbol, kind, operands }}\n}}\n\n#[rustfmt::skip]\npub const {const_prefix}_FIELD_EXPRS: &[{stage_type_prefix}FieldExprPlan] = &[\n{rows}\n];\n" + ) +} + pub(crate) fn emit_sumcheck_claim_constants( stage_type_prefix: &str, const_prefix: &str, @@ -466,6 +505,12 @@ pub(crate) fn emit_sumcheck_batch_constants( ) -> String { let mut source = String::new(); for (index, batch) in batches.iter().enumerate() { + emit_str_array_if_not_inline( + &mut source, + &format!("{const_prefix}_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS"), + &batch.claim_operands, + 4, + ); source.push_str(&emit_usize_array( &format!("{const_prefix}_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"), &batch.round_schedule, @@ -475,6 +520,11 @@ pub(crate) fn emit_sumcheck_batch_constants( .iter() .enumerate() .map(|(index, batch)| { + let claim_operands = str_slice_ref_expr( + &format!("{const_prefix}_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS"), + &batch.claim_operands, + 4, + ); format!( " {stage_type_prefix}SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: {}, claim_label: {}, round_label: {}, round_schedule: {const_prefix}_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", rust_str(&batch.symbol), @@ -482,7 +532,7 @@ pub(crate) fn emit_sumcheck_batch_constants( rust_str(&batch.proof_slot), rust_str(&batch.policy), batch.count, - rust_str_slice_expr(&batch.claim_operands), + claim_operands, rust_str(&batch.claim_label), rust_str(&batch.round_label) ) @@ -588,6 +638,28 @@ pub(crate) fn emit_point_slice_constants( ) } +pub(crate) fn emit_point_zero_constants( + stage_type_prefix: &str, + const_prefix: &str, + zeros: &[VerifierPointZeroPlan], +) -> String { + let zeros = zeros + .iter() + .map(|zero| { + format!( + " {stage_type_prefix}PointZeroPlan {{ symbol: {}, field: {}, arity: {} }},", + rust_str(&zero.symbol), + rust_str(&zero.field), + zero.arity + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_POINT_ZEROS: &[{stage_type_prefix}PointZeroPlan] = &[\n{zeros}\n];\n\n" + ) +} + pub(crate) fn emit_point_concat_constants( stage_type_prefix: &str, const_prefix: &str, @@ -707,6 +779,33 @@ fn rust_str_slice_expr(values: &[String]) -> String { format!("&[{values}]") } +fn str_slice_ref_expr(name: &str, values: &[String], inline_limit: usize) -> String { + if values.len() <= inline_limit { + return rust_str_slice_expr(values); + } + name.to_owned() +} + +fn emit_str_array_if_not_inline( + source: &mut String, + name: &str, + values: &[String], + inline_limit: usize, +) { + if values.len() <= inline_limit { + return; + } + let entries = values + .iter() + .map(|value| rust_str(value)) + .collect::>() + .join(",\n "); + let _ = write!( + source, + "pub const {name}: &[&str] = &[\n {entries},\n];\n\n" + ); +} + fn rust_str(value: &str) -> String { format!("{value:?}") } From 854479f9446eb1494891247cdfd4329512c20b43 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 08:21:12 -0600 Subject: [PATCH 081/171] refactor(bolt): plan stage7 verifier emission Route Stage 7 verifier constants through the shared verifier-stage plan and regenerate the checked-in verifier artifact. --- .../src/protocols/jolt/emit/rust/stage7.rs | 501 +++++++++++++----- crates/jolt-verifier/src/stages/stage7.rs | 4 +- 2 files changed, 358 insertions(+), 147 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index ee867e4431..4e958953bf 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -22,6 +22,7 @@ use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputFunctionFamilyPlan as Stage7SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan as Stage7SumcheckOutputProductFamilyPlan, }; +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::schema::verify_cpu_schema; use super::plan_tokens::{ @@ -40,6 +41,7 @@ const STAGE7_KERNEL_ABIS: &[(&str, &str)] = &[ #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage7CpuProgram { pub role: Role, + pub(crate) verifier_plan: Option, pub params: Stage7Params, pub steps: Vec, pub transcript_squeezes: Vec, @@ -608,6 +610,7 @@ impl Stage7CpuProgram { let role = module .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; + let is_verifier = role == Role::Verifier; if role == Role::Prover { verifier_output_claims::prune_output_only_field_exprs( &mut field_exprs, @@ -631,9 +634,10 @@ impl Stage7CpuProgram { Vec::new() }; - Ok(Self { + let mut program = Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, role, + verifier_plan: None, steps, transcript_squeezes, transcript_absorb_bytes, @@ -657,9 +661,228 @@ impl Stage7CpuProgram { opening_claims, opening_equalities, opening_batches, + }; + if is_verifier { + program.verifier_plan = Some(program.plan_verifier()?); + } + Ok(program) + } + + fn plan_verifier(&self) -> Result { + Ok(VerifierStagePlan { + steps: self + .steps + .iter() + .map(|step| { + verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) + }) + .collect::, EmitError>>()?, + transcript_squeezes: self + .transcript_squeezes + .iter() + .map(|squeeze| { + verifier_plan::VerifierTranscriptSqueezePlan::from_cpu( + &squeeze.symbol, + &squeeze.label, + &squeeze.kind, + squeeze.count, + ) + }) + .collect::, EmitError>>()?, + transcript_absorb_bytes: self + .transcript_absorb_bytes + .iter() + .map(|absorb| { + verifier_plan::VerifierTranscriptAbsorbBytesPlan::from_cpu( + &absorb.symbol, + &absorb.label, + &absorb.payload, + ) + }) + .collect(), + opening_inputs: self + .opening_inputs + .iter() + .map(|input| { + verifier_plan::VerifierOpeningInputPlan::from_cpu( + &input.symbol, + &input.source_stage, + &input.source_claim, + &input.oracle, + &input.domain, + input.point_arity, + &input.claim_kind, + ) + }) + .collect::, EmitError>>()?, + field_exprs: self + .field_exprs + .iter() + .map(|expr| { + verifier_plan::VerifierFieldExprPlan::from_cpu( + &expr.symbol, + &expr.formula, + &expr.operands, + ) + }) + .collect::, EmitError>>()?, + claims: self + .claims + .iter() + .map(|claim| { + Ok(verifier_plan::VerifierSumcheckClaimPlan { + symbol: claim.symbol.clone(), + stage: claim.stage.clone(), + domain: claim.domain.clone(), + num_rounds: claim.num_rounds, + degree: claim.degree, + claim: claim.claim.clone(), + relation: verifier_plan::required_relation_from_cpu( + claim.relation.as_deref(), + "claim", + &claim.symbol, + )?, + claim_value: claim.claim_value.clone(), + }) + }) + .collect::, EmitError>>()?, + batches: self + .batches + .iter() + .map(|batch| verifier_plan::VerifierSumcheckBatchPlan { + symbol: batch.symbol.clone(), + stage: batch.stage.clone(), + proof_slot: batch.proof_slot.clone(), + policy: batch.policy.clone(), + count: batch.count, + claim_operands: batch.claim_operands.clone(), + claim_label: batch.claim_label.clone(), + round_label: batch.round_label.clone(), + round_schedule: batch.round_schedule.clone(), + }) + .collect(), + drivers: self + .drivers + .iter() + .map(|driver| { + Ok(verifier_plan::VerifierSumcheckDriverPlan { + symbol: driver.symbol.clone(), + stage: driver.stage.clone(), + proof_slot: driver.proof_slot.clone(), + relation: verifier_plan::required_relation_from_cpu( + driver.relation.as_deref(), + "driver", + &driver.symbol, + )?, + batch: driver.batch.clone(), + policy: driver.policy.clone(), + round_schedule: driver.round_schedule.clone(), + claim_label: driver.claim_label.clone(), + round_label: driver.round_label.clone(), + num_rounds: driver.num_rounds, + degree: driver.degree, + }) + }) + .collect::, EmitError>>()?, + instance_results: self + .instance_results + .iter() + .map(|instance| { + Ok(verifier_plan::VerifierSumcheckInstanceResultPlan { + symbol: instance.symbol.clone(), + source: instance.source.clone(), + claim: instance.claim.clone(), + relation: verifier_plan::relation_from_cpu(&instance.relation)?, + index: instance.index, + point_arity: instance.point_arity, + num_rounds: instance.num_rounds, + round_offset: instance.round_offset, + point_order: verifier_plan::sumcheck_point_order_from_cpu( + &instance.point_order, + )?, + degree: instance.degree, + }) + }) + .collect::, EmitError>>()?, + point_zeros: self + .point_zeros + .iter() + .map(|zero| verifier_plan::VerifierPointZeroPlan { + symbol: zero.symbol.clone(), + field: zero.field.clone(), + arity: zero.arity, + }) + .collect(), + point_slices: self + .point_slices + .iter() + .map(|slice| verifier_plan::VerifierPointSlicePlan { + symbol: slice.symbol.clone(), + source: slice.source.clone(), + offset: slice.offset, + length: slice.length, + input: slice.input.clone(), + }) + .collect(), + point_concats: self + .point_concats + .iter() + .map(|concat| verifier_plan::VerifierPointConcatPlan { + symbol: concat.symbol.clone(), + layout: concat.layout.clone(), + arity: concat.arity, + inputs: concat.inputs.clone(), + }) + .collect(), + opening_claims: self + .opening_claims + .iter() + .map(|claim| { + Ok(verifier_plan::VerifierOpeningClaimPlan { + symbol: claim.symbol.clone(), + oracle: claim.oracle.clone(), + domain: claim.domain.clone(), + point_arity: claim.point_arity, + claim_kind: verifier_plan::claim_kind_from_cpu(&claim.claim_kind)?, + point_source: claim.point_source.clone(), + eval_source: claim.eval_source.clone(), + }) + }) + .collect::, EmitError>>()?, + opening_equalities: self + .opening_equalities + .iter() + .map(|equality| { + Ok(verifier_plan::VerifierOpeningClaimEqualityPlan { + symbol: equality.symbol.clone(), + mode: verifier_plan::opening_equality_mode_from_cpu(&equality.mode)?, + lhs: equality.lhs.clone(), + rhs: equality.rhs.clone(), + }) + }) + .collect::, EmitError>>()?, + opening_batches: self + .opening_batches + .iter() + .map(|batch| verifier_plan::VerifierOpeningBatchPlan { + symbol: batch.symbol.clone(), + stage: batch.stage.clone(), + proof_slot: batch.proof_slot.clone(), + policy: batch.policy.clone(), + count: batch.count, + ordered_claims: batch.ordered_claims.clone(), + claim_operands: batch.claim_operands.clone(), + }) + .collect(), }) } + fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { + self.verifier_plan + .as_ref() + .ok_or_else(|| EmitError::new("missing stage7 verifier plan")) + } + fn verify_supported_target(&self) -> Result<(), EmitError> { require_supported_symbol("field", &self.params.field, "bn254_fr")?; require_supported_symbol("pcs", &self.params.pcs, "dory")?; @@ -1464,7 +1687,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); let mut source = self.emit_shared_constants()?; source.push_str(&self.emit_kernel_constants()); source.push_str(&self.emit_sumcheck_claim_constants()?); - source.push_str(&self.emit_sumcheck_batch_constants()); + source.push_str(&self.emit_sumcheck_batch_constants()?); source.push_str(&self.emit_sumcheck_driver_constants()?); if self.role == Role::Verifier { source.push_str(&self.emit_verifier_output_claim_constants()?); @@ -1521,7 +1744,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); ); source.push_str(&self.emit_program_step_constants()?); source.push_str(&self.emit_transcript_squeeze_constants()?); - source.push_str(&self.emit_transcript_absorb_bytes_constants()); + source.push_str(&self.emit_transcript_absorb_bytes_constants()?); source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); @@ -1529,6 +1752,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); } fn emit_program_step_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_program_step_constants( + "Stage7", + "STAGE7", + &plan.steps, + )); + } let steps = self .steps .iter() @@ -1549,6 +1780,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); } fn emit_transcript_squeeze_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_transcript_squeeze_constants( + "Stage7", + "STAGE7", + &plan.transcript_squeezes, + )); + } let squeezes = self .transcript_squeezes .iter() @@ -1568,7 +1807,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); )) } - fn emit_transcript_absorb_bytes_constants(&self) -> String { + fn emit_transcript_absorb_bytes_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_transcript_absorb_bytes_constants( + "Stage7", + "STAGE7", + &plan.transcript_absorb_bytes, + )); + } let absorbs = self .transcript_absorb_bytes .iter() @@ -1582,12 +1829,20 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); }) .collect::>() .join("\n"); - format!( + Ok(format!( "pub const STAGE7_TRANSCRIPT_ABSORB_BYTES: &[Stage7TranscriptAbsorbBytesPlan] = &[\n{absorbs}\n];\n\n" - ) + )) } fn emit_opening_input_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_input_constants( + "Stage7", + "STAGE7", + &plan.opening_inputs, + )); + } let inputs = self .opening_inputs .iter() @@ -1631,32 +1886,13 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { - let rows = self - .field_exprs - .chunks(8) - .map(|chunk| { - let exprs = chunk - .iter() - .map(|expr| { - Ok(format!( - "stage7_field_expr({}, {}, {})", - rust_str(&expr.symbol), - super::plan_tokens::role_field_expr_kind_expr( - "Stage7", - &self.role, - &expr.formula - )?, - super::plan_tokens::rust_str_slice_expr(&expr.operands) - )) - }) - .collect::, EmitError>>()? - .join(", "); - Ok(format!(" {exprs},")) - }) - .collect::, EmitError>>()? - .join("\n"); - return Ok(format!( - "const fn stage7_field_expr(symbol: &'static str, kind: Stage7FieldExprKind, operands: &'static [&'static str]) -> Stage7FieldExprPlan {{\n Stage7FieldExprPlan {{ symbol, kind, operands }}\n}}\n\n#[rustfmt::skip]\npub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[\n{rows}\n];\n" + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_field_expr_constants_chunked( + "Stage7", + "STAGE7", + "stage7_field_expr", + &plan.field_exprs, + 8, )); } @@ -1723,31 +1959,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); fn emit_sumcheck_claim_constants(&self) -> Result { if self.role == Role::Verifier { - let claims = self - .claims - .iter() - .map(|claim| { - Ok(format!( - " Stage7SumcheckClaimPlan {{ symbol: {}, stage: {}, domain: {}, num_rounds: {}, degree: {}, claim: {}, kernel: {}, relation: {}, claim_value: {} }},", - rust_str(&claim.symbol), - rust_str(&claim.stage), - rust_str(&claim.domain), - claim.num_rounds, - claim.degree, - rust_str(&claim.claim), - rust_option_str(claim.kernel.as_deref()), - super::plan_tokens::role_optional_relation_kind_expr( - "Stage7", - &self.role, - claim.relation.as_deref() - )?, - rust_str(&claim.claim_value) - )) - }) - .collect::, EmitError>>()? - .join("\n"); - return Ok(format!( - "pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[\n{claims}\n];\n" + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_claim_constants( + "Stage7", + "STAGE7", + &plan.claims, )); } @@ -1791,44 +2007,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); Ok(source) } - fn emit_sumcheck_batch_constants(&self) -> String { + fn emit_sumcheck_batch_constants(&self) -> Result { if self.role == Role::Verifier { - let mut source = String::new(); - for (index, batch) in self.batches.iter().enumerate() { - source.push_str(&emit_str_array( - &format!("STAGE7_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS"), - &batch.claim_operands, - )); - source.push_str(&emit_usize_array( - &format!("STAGE7_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE"), - &batch.round_schedule, - )); - } - let batches = self - .batches - .iter() - .enumerate() - .map(|(index, batch)| { - format!( - " Stage7SumcheckBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, claim_operands: STAGE7_SUMCHECK_BATCH_{index}_CLAIM_OPERANDS, claim_label: {}, round_label: {}, round_schedule: STAGE7_SUMCHECK_BATCH_{index}_ROUND_SCHEDULE }},", - rust_str(&batch.symbol), - rust_str(&batch.stage), - rust_str(&batch.proof_slot), - rust_str(&batch.policy), - batch.count, - rust_str(&batch.claim_label), - rust_str(&batch.round_label) - ) - }) - .collect::>() - .join("\n"); - push_format( - &mut source, - format_args!( - "pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[\n{batches}\n];\n" - ), - ); - return source; + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_batch_constants( + "Stage7", + "STAGE7", + &plan.batches, + )); } let mut source = String::new(); @@ -1870,10 +2056,18 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); "pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[\n{batches}\n];\n" ), ); - source + Ok(source) } fn emit_sumcheck_driver_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_driver_constants( + "Stage7", + "STAGE7", + &plan.drivers, + )); + } let mut source = String::new(); for (index, driver) in self.drivers.iter().enumerate() { source.push_str(&emit_usize_array( @@ -1920,16 +2114,24 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); let mut source = String::new(); source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); - source.push_str(&self.emit_point_zero_constants()); - source.push_str(&self.emit_point_slice_constants()); - source.push_str(&self.emit_point_concat_constants()); + source.push_str(&self.emit_point_zero_constants()?); + source.push_str(&self.emit_point_slice_constants()?); + source.push_str(&self.emit_point_concat_constants()?); source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_claim_equality_constants()?); - source.push_str(&self.emit_opening_batch_constants()); + source.push_str(&self.emit_opening_batch_constants()?); Ok(source) } fn emit_sumcheck_instance_result_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_sumcheck_instance_result_constants( + "Stage7", + "STAGE7", + &plan.instance_results, + )); + } let instances = self .instance_results .iter() @@ -1998,7 +2200,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); ) } - fn emit_point_zero_constants(&self) -> String { + fn emit_point_zero_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_point_zero_constants( + "Stage7", + "STAGE7", + &plan.point_zeros, + )); + } let zeros = self .point_zeros .iter() @@ -2012,10 +2222,20 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); }) .collect::>() .join("\n"); - format!("pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[\n{zeros}\n];\n\n") + Ok(format!( + "pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[\n{zeros}\n];\n\n" + )) } - fn emit_point_slice_constants(&self) -> String { + fn emit_point_slice_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_point_slice_constants( + "Stage7", + "STAGE7", + &plan.point_slices, + )); + } let slices = self .point_slices .iter() @@ -2031,28 +2251,19 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); }) .collect::>() .join("\n"); - format!("pub const STAGE7_POINT_SLICES: &[Stage7PointSlicePlan] = &[\n{slices}\n];\n\n") + Ok(format!( + "pub const STAGE7_POINT_SLICES: &[Stage7PointSlicePlan] = &[\n{slices}\n];\n\n" + )) } - fn emit_point_concat_constants(&self) -> String { + fn emit_point_concat_constants(&self) -> Result { if self.role == Role::Verifier { - let concats = self - .point_concats - .iter() - .map(|concat| { - format!( - " Stage7PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},", - rust_str(&concat.symbol), - rust_str(&concat.layout), - concat.arity, - super::plan_tokens::rust_str_slice_expr(&concat.inputs) - ) - }) - .collect::>() - .join("\n"); - return format!( - "pub const STAGE7_POINT_CONCATS: &[Stage7PointConcatPlan] = &[\n{concats}\n];\n" - ); + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_point_concat_constants( + "Stage7", + "STAGE7", + &plan.point_concats, + )); } let mut source = String::new(); @@ -2082,10 +2293,18 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); "pub const STAGE7_POINT_CONCATS: &[Stage7PointConcatPlan] = &[\n{concats}\n];\n" ), ); - source + Ok(source) } fn emit_opening_claim_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_claim_constants( + "Stage7", + "STAGE7", + &plan.opening_claims, + )); + } let claims = self .opening_claims .iter() @@ -2109,6 +2328,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); } fn emit_opening_claim_equality_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_claim_equality_constants( + "Stage7", + "STAGE7", + &plan.opening_equalities, + )); + } let equalities = self .opening_equalities .iter() @@ -2128,28 +2355,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); )) } - fn emit_opening_batch_constants(&self) -> String { + fn emit_opening_batch_constants(&self) -> Result { if self.role == Role::Verifier { - let batches = self - .opening_batches - .iter() - .map(|batch| { - format!( - " Stage7OpeningBatchPlan {{ symbol: {}, stage: {}, proof_slot: {}, policy: {}, count: {}, ordered_claims: {}, claim_operands: {} }},", - rust_str(&batch.symbol), - rust_str(&batch.stage), - rust_str(&batch.proof_slot), - rust_str(&batch.policy), - batch.count, - super::plan_tokens::rust_str_slice_expr(&batch.ordered_claims), - super::plan_tokens::rust_str_slice_expr(&batch.claim_operands) - ) - }) - .collect::>() - .join("\n"); - return format!( - "pub const STAGE7_OPENING_BATCHES: &[Stage7OpeningBatchPlan] = &[\n{batches}\n];\n" - ); + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_opening_batch_constants( + "Stage7", + "STAGE7", + &plan.opening_batches, + )); } let mut source = String::new(); @@ -2185,7 +2398,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); "pub const STAGE7_OPENING_BATCHES: &[Stage7OpeningBatchPlan] = &[\n{batches}\n];\n" ), ); - source + Ok(source) } fn emit_entrypoint(&self) -> &'static str { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index b08108e1a6..a54d72e005 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -219,12 +219,10 @@ pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[ Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some(Stage7RelationKind::Stage7HammingWeightClaimReduction), claim_value: "stage7.hamming_weight_claim_reduction.claim_expr.partial115" }, ]; -pub const STAGE7_SUMCHECK_BATCH_0_CLAIM_OPERANDS: &[&str] = &["stage7.hamming_weight_claim_reduction.input"]; - pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_BATCHES: &[Stage7SumcheckBatchPlan] = &[ - Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, claim_operands: STAGE7_SUMCHECK_BATCH_0_CLAIM_OPERANDS, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, + Stage7SumcheckBatchPlan { symbol: "stage7.batch", stage: "stage7", proof_slot: "stage7.sumcheck", policy: "jolt_core_stage7_aligned", count: 1, claim_operands: &["stage7.hamming_weight_claim_reduction.input"], claim_label: "sumcheck_claim", round_label: "sumcheck_poly", round_schedule: STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE }, ]; pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4]; From 0ea20fbe37d1925a258d83a11c71113fb573ee75 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 10:03:34 -0600 Subject: [PATCH 082/171] refactor(bolt): derive stage6 bytecode eval family Derive the Stage 6 bytecode read-RAF output eval family from verifier CPU eval rows instead of hard-coding BytecodeRa_0..2. Thread local output points through the verifier runtime so Stage 5 structured polynomial claims can name local relation points, and keep dynamic equivalence adapters aligned with typed output-claim enums. --- crates/bolt-verifier-runtime/src/lib.rs | 44 ++++- .../src/protocols/jolt/emit/rust/stage3.rs | 4 +- .../src/protocols/jolt/emit/rust/stage4.rs | 4 +- .../src/protocols/jolt/emit/rust/stage5.rs | 5 +- .../src/protocols/jolt/emit/rust/stage6.rs | 100 ++++++++++- .../src/protocols/jolt/emit/rust/stage7.rs | 4 +- .../jolt/stage6_bytecode_read_raf_plan.rs | 38 ++-- .../protocols/jolt/verifier_output_claims.rs | 37 ++++ crates/jolt-equivalence/src/plan_adapters.rs | 17 +- crates/jolt-verifier/src/stages/stage3.rs | 4 +- crates/jolt-verifier/src/stages/stage4.rs | 4 +- crates/jolt-verifier/src/stages/stage5.rs | 5 +- crates/jolt-verifier/src/stages/stage6.rs | 168 +++++++++--------- crates/jolt-verifier/src/stages/stage7.rs | 4 +- 14 files changed, 293 insertions(+), 145 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 1b3b28d9ef..857ec02bfe 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -629,6 +629,12 @@ pub struct NamedScalar { pub value: F, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct NamedPoint<'a, F: Field> { + pub symbol: &'static str, + pub point: &'a [F], +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct NamedEvalFamilyPlan { pub symbol: &'static str, @@ -1247,6 +1253,7 @@ pub fn evaluate_sumcheck_output_claim( instance_symbol: &'static str, evals: &[StageNamedEval], local_scalars: &[NamedScalar], + local_points: &[NamedPoint<'_, Fr>], local_point: &[Fr], ) -> Result { let mut scratch = ScratchScalars::default(); @@ -1262,25 +1269,26 @@ pub fn evaluate_sumcheck_output_claim( scratch.insert(eval.name, eval.value); } for polynomial_eval in plan.polynomial_evals { - if polynomial_eval.x_point.source != instance_symbol { - return Err(RuntimePlanError::InvalidProof { - driver: instance_symbol, - reason: "structured polynomial x-point source mismatch", - }); - } + let x_raw_point = output_claim_x_point_source( + polynomial_eval.x_point.source, + instance_symbol, + local_points, + local_point, + store, + )?; let y_raw_point = store.point_or(polynomial_eval.y_point.source, |symbol| { RuntimePlanError::MissingValue { symbol } })?; let x_point = evaluate_structured_polynomial_point( polynomial_eval.x_point, - local_point, - local_point, + x_raw_point, + x_raw_point, y_raw_point, )?; let y_point = evaluate_structured_polynomial_point( polynomial_eval.y_point, y_raw_point, - local_point, + x_raw_point, y_raw_point, )?; let value = evaluate_structured_polynomial(polynomial_eval.polynomial, &x_point, y_point)?; @@ -1313,6 +1321,7 @@ pub fn evaluate_sumcheck_instance_output_claim( instance: &SumcheckInstanceResultPlan, evals: &[StageNamedEval], local_scalars: &[NamedScalar], + local_points: &[NamedPoint<'_, Fr>], local_point: &[Fr], ) -> Result { let output_claim = output_claims @@ -1329,10 +1338,27 @@ pub fn evaluate_sumcheck_instance_output_claim( instance.symbol, evals, local_scalars, + local_points, local_point, ) } +fn output_claim_x_point_source<'a>( + source: &'static str, + instance_symbol: &'static str, + local_points: &'a [NamedPoint<'a, Fr>], + local_point: &'a [Fr], + store: &'a ValueStore, +) -> Result<&'a [Fr], RuntimePlanError> { + local_points + .iter() + .find(|point| point.symbol == source) + .map(|point| point.point) + .or_else(|| (source == instance_symbol).then_some(local_point)) + .or_else(|| store.try_point(source)) + .ok_or(RuntimePlanError::MissingValue { symbol: source }) +} + fn evaluate_sumcheck_output_eval_family( family: &SumcheckOutputEvalFamilyPlan, store: &ValueStore, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index ddf9063934..1931ca4f76 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -2350,9 +2350,7 @@ fn expected_batched_output_claim( program.field_exprs, store, instance, - evals, - &[], - local_point, + evals, &[], &[], local_point, )?; expected += *coefficient * value; } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index e2ad405fd7..9920186c70 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -2601,9 +2601,7 @@ fn expected_batched_output_claim( program.field_exprs, store, instance, - evals, - &[], - local_point, + evals, &[], &[], local_point, )?; expected += *coefficient * value; } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index b106ebc2d0..da2b9d2bd3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -2683,6 +2683,7 @@ fn expected_batched_output_claim( instance, evals, &local_scalars, + &[bolt_verifier_runtime::NamedPoint { symbol: STAGE5_INSTRUCTION_READ_RAF_PLAN.point, point: local_point }], local_point, )? } @@ -2693,9 +2694,7 @@ fn expected_batched_output_claim( program.field_exprs, store, instance, - evals, - &[], - local_point, + evals, &[], &[], local_point, )? } relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index faeb07f3c1..2b7aff8bf8 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -651,7 +651,10 @@ impl Stage6CpuProgram { Vec::new() }; if role == Role::Verifier { - output_claims.push(stage6_bytecode_read_raf_output_claim_plan()); + let bytecode_ra_evals = stage6_bytecode_read_raf_eval_names(&evals)?; + output_claims.push(stage6_bytecode_read_raf_output_claim_plan( + &bytecode_ra_evals, + )); } let mut program = Self { @@ -1768,7 +1771,6 @@ const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { }; "#, ); - source.push_str(&emit_stage6_bytecode_read_raf_plan_constants()); source.push_str( r#" #[derive(Debug)] @@ -1798,6 +1800,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); if self.role == Role::Verifier { + let bytecode_ra_evals = stage6_bytecode_read_raf_eval_names(&self.evals)?; + source.push_str(&emit_stage6_bytecode_read_raf_plan_constants( + &bytecode_ra_evals, + )); source.push_str(&self.emit_verifier_output_claim_constants()?); } let output_claims_field = if self.role == Role::Verifier { @@ -2873,7 +2879,7 @@ fn expected_plan_output_claim( instance, evals, local_scalars, - local_point, + &[], local_point, )?) } @@ -2908,6 +2914,46 @@ fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi)) } +fn stage6_bytecode_read_raf_eval_names( + evals: &[Stage6SumcheckEvalPlan], +) -> Result, EmitError> { + const PREFIX: &str = "stage6.bytecode_read_raf.eval.BytecodeRa_"; + + let mut indexed_evals = BTreeMap::new(); + for eval in evals { + let Some(suffix) = eval.name.strip_prefix(PREFIX) else { + continue; + }; + let index = suffix.parse::().map_err(|_| { + EmitError::new(format!( + "stage6 bytecode read-RAF eval `{}` has non-numeric BytecodeRa suffix", + eval.name + )) + })?; + if indexed_evals.insert(index, eval.name.clone()).is_some() { + return Err(EmitError::new(format!( + "stage6 bytecode read-RAF eval family has duplicate BytecodeRa_{index}" + ))); + } + } + if indexed_evals.is_empty() { + return Err(EmitError::new( + "stage6 bytecode read-RAF eval family is missing BytecodeRa evals", + )); + } + + let mut eval_names = Vec::with_capacity(indexed_evals.len()); + for (expected, (index, eval)) in indexed_evals.into_iter().enumerate() { + if index != expected { + return Err(EmitError::new(format!( + "stage6 bytecode read-RAF eval family is not contiguous: expected BytecodeRa_{expected}, got BytecodeRa_{index}" + ))); + } + eval_names.push(eval); + } + Ok(eval_names) +} + fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) @@ -3027,7 +3073,10 @@ fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { #[cfg(test)] mod tests { - use super::{stage6_kernel_abi, STAGE6_KERNEL_ABIS}; + use super::{ + stage6_bytecode_read_raf_eval_names, stage6_kernel_abi, Stage6SumcheckEvalPlan, + STAGE6_KERNEL_ABIS, + }; #[test] fn stage6_kernel_abi_contracts_cover_supported_relations() { @@ -3042,4 +3091,47 @@ mod tests { ); assert_eq!(stage6_kernel_abi("jolt.stage7.batched"), None); } + + #[test] + fn stage6_bytecode_read_raf_eval_family_is_sorted_by_suffix() { + let evals = vec![ + eval("stage6.bytecode_read_raf.eval.BytecodeRa_2"), + eval("stage6.booleanity.eval.BytecodeRa_0"), + eval("stage6.bytecode_read_raf.eval.BytecodeRa_0"), + eval("stage6.bytecode_read_raf.eval.BytecodeRa_1"), + ]; + + assert_eq!( + stage6_bytecode_read_raf_eval_names(&evals).unwrap(), + vec![ + "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(), + ] + ); + } + + #[test] + fn stage6_bytecode_read_raf_eval_family_rejects_gaps() { + let evals = vec![ + eval("stage6.bytecode_read_raf.eval.BytecodeRa_0"), + eval("stage6.bytecode_read_raf.eval.BytecodeRa_2"), + ]; + + let error = stage6_bytecode_read_raf_eval_names(&evals) + .unwrap_err() + .to_string(); + + assert!(error.contains("not contiguous")); + } + + fn eval(name: &'static str) -> Stage6SumcheckEvalPlan { + Stage6SumcheckEvalPlan { + symbol: name.to_owned(), + source: "stage6.sumcheck".to_owned(), + name: name.to_owned(), + index: 0, + oracle: "BytecodeRa_0".to_owned(), + } + } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 4e958953bf..24798d5b12 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -2700,9 +2700,7 @@ fn expected_batched_output_claim( program.field_exprs, store, instance, - evals, - &[], - local_point, + evals, &[], &[], local_point, )? } relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }), diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 4c5e5c9919..f3040e7f19 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -11,7 +11,6 @@ pub(crate) struct BytecodeReadRafPlan { pub(crate) bytecode_ra_eval_names_const: &'static str, pub(crate) bytecode_ra_eval_family_const: &'static str, pub(crate) bytecode_ra_eval_family_symbol: &'static str, - pub(crate) bytecode_ra_evals: &'static [&'static str], pub(crate) entries: &'static str, pub(crate) entry_bytecode_index: &'static str, pub(crate) stages_const: &'static str, @@ -316,11 +315,6 @@ const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { bytecode_ra_eval_names_const: "STAGE6_BYTECODE_RA_EVAL_NAMES", bytecode_ra_eval_family_const: "STAGE6_BYTECODE_RA_EVALS", bytecode_ra_eval_family_symbol: "stage6.bytecode_read_raf.eval.BytecodeRa", - bytecode_ra_evals: &[ - "stage6.bytecode_read_raf.eval.BytecodeRa_0", - "stage6.bytecode_read_raf.eval.BytecodeRa_1", - "stage6.bytecode_read_raf.eval.BytecodeRa_2", - ], entries: "stage6.bytecode_read_raf.entries", entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", stages_const: "STAGE6_BYTECODE_STAGES", @@ -336,8 +330,8 @@ const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; -pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants() -> String { - emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN) +pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants(bytecode_ra_evals: &[String]) -> String { + emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN, bytecode_ra_evals) } #[cfg(test)] @@ -345,19 +339,21 @@ pub(crate) fn stage6_bytecode_read_raf_output_contribution_symbol() -> &'static STAGE6_BYTECODE_READ_RAF_PLAN.output_contribution } -pub(crate) fn stage6_bytecode_read_raf_output_claim_plan() -> SumcheckOutputClaimPlan { - STAGE6_BYTECODE_READ_RAF_PLAN.output_claim_plan() +pub(crate) fn stage6_bytecode_read_raf_output_claim_plan( + bytecode_ra_evals: &[String], +) -> SumcheckOutputClaimPlan { + STAGE6_BYTECODE_READ_RAF_PLAN.output_claim_plan(bytecode_ra_evals) } impl BytecodeReadRafPlan { - fn output_claim_plan(&self) -> SumcheckOutputClaimPlan { + fn output_claim_plan(&self, bytecode_ra_evals: &[String]) -> SumcheckOutputClaimPlan { let product_family = SumcheckOutputProductFamilyPlan { symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf".to_owned(), gamma: None, terms: vec![SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: std::iter::once(self.output_contribution.to_owned()) - .chain(self.bytecode_ra_evals.iter().map(|eval| (*eval).to_owned())) + .chain(bytecode_ra_evals.iter().cloned()) .collect(), factors: Vec::new(), }], @@ -374,7 +370,7 @@ impl BytecodeReadRafPlan { } } -fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { +fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan, bytecode_ra_evals: &[String]) -> String { let mut source = "\n".to_owned(); push_format( @@ -382,7 +378,7 @@ fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan) -> String { format_args!( "#[rustfmt::skip]\nconst {}: &[&str] = &[{}];\n", plan.bytecode_ra_eval_names_const, - plan.bytecode_ra_evals + bytecode_ra_evals .iter() .map(|eval| rust_str(eval)) .collect::>() @@ -586,6 +582,12 @@ mod tests { BytecodeReadRafTermPlan, BytecodeRegister, STAGE6_BYTECODE_READ_RAF_PLAN, }; + fn bytecode_ra_evals() -> Vec { + (0..4) + .map(|index| format!("stage6.bytecode_read_raf.eval.BytecodeRa_{index}")) + .collect() + } + #[test] fn stage6_bytecode_plan_rows_encode_the_read_raf_reduction() { let plan = &STAGE6_BYTECODE_READ_RAF_PLAN; @@ -678,7 +680,8 @@ mod tests { #[test] fn stage6_bytecode_output_claim_plan_uses_point_derived_contribution() { - let claim = stage6_bytecode_read_raf_output_claim_plan(); + let bytecode_ra_evals = bytecode_ra_evals(); + let claim = stage6_bytecode_read_raf_output_claim_plan(&bytecode_ra_evals); assert_eq!(claim.relation, "jolt.stage6.bytecode_read_raf"); assert_eq!( @@ -700,19 +703,22 @@ mod tests { "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_3".to_owned(), ] ); } #[test] fn stage6_bytecode_plan_renderer_emits_stage67_constants() { - let source = emit_stage6_bytecode_read_raf_plan_constants(); + let bytecode_ra_evals = bytecode_ra_evals(); + let source = emit_stage6_bytecode_read_raf_plan_constants(&bytecode_ra_evals); assert!(source.contains("const STAGE6_BYTECODE_STAGE1_TERMS")); assert!(source.contains("Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }")); assert!(source.contains("Stage67BytecodeFlag::IsInterleaved")); assert!(source.contains("Stage67BytecodeRegister::Rs2")); assert!(source.contains("const STAGE6_BYTECODE_RA_EVAL_NAMES")); + assert!(source.contains("\"stage6.bytecode_read_raf.eval.BytecodeRa_3\"")); assert!(source.contains( "const STAGE6_BYTECODE_RA_EVALS: bolt_verifier_runtime::NamedEvalFamilyPlan" )); diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index e37d2aed49..94d4fcfb27 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -15,6 +15,14 @@ pub enum StructuredPolynomialKind { } impl StructuredPolynomialKind { + pub fn as_str(self) -> &'static str { + match self { + Self::Eq => "eq", + Self::EqPlusOne => "eq_plus_one", + Self::Lt => "lt", + } + } + pub fn from_cpu_attr(value: &str) -> Result { match value { "eq" => Ok(Self::Eq), @@ -35,6 +43,14 @@ pub enum StructuredPolynomialPointSegment { } impl StructuredPolynomialPointSegment { + pub fn as_str(self) -> &'static str { + match self { + Self::Full => "full", + Self::Prefix => "prefix", + Self::Suffix => "suffix", + } + } + pub fn from_cpu_attr(value: &str) -> Result { match value { "full" => Ok(Self::Full), @@ -55,6 +71,14 @@ pub enum StructuredPolynomialPointLength { } impl StructuredPolynomialPointLength { + pub fn as_str(self) -> &'static str { + match self { + Self::Full => "full", + Self::XPoint => "x_point", + Self::YPoint => "y_point", + } + } + pub fn from_cpu_attr(value: &str) -> Result { match value { "full" => Ok(Self::Full), @@ -74,6 +98,13 @@ pub enum StructuredPolynomialPointOrder { } impl StructuredPolynomialPointOrder { + pub fn as_str(self) -> &'static str { + match self { + Self::AsIs => "as_is", + Self::Reverse => "reverse", + } + } + pub fn from_cpu_attr(value: &str) -> Result { match value { "as_is" => Ok(Self::AsIs), @@ -91,6 +122,12 @@ pub enum SumcheckOutputFunctionKind { } impl SumcheckOutputFunctionKind { + pub fn as_str(self) -> &'static str { + match self { + Self::BooleanZero => "boolean_zero", + } + } + pub fn from_cpu_attr(value: &str) -> Result { match value { "boolean_zero" => Ok(Self::BooleanZero), diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 8afe44d599..73ac99af4c 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -630,18 +630,18 @@ macro_rules! define_stage_adapter_impl { .iter() .map(|value| $module::$output_value { symbol: super::leak_str(&value.symbol), - polynomial: super::generated_structured_polynomial_kind(&value.polynomial), + polynomial: super::generated_structured_polynomial_kind(value.polynomial.as_str()), x_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { source: super::leak_str(&value.x_point.source), - segment: super::generated_structured_polynomial_point_segment(&value.x_point.segment), - length: super::generated_structured_polynomial_point_length(&value.x_point.length), - order: super::generated_structured_polynomial_point_order(&value.x_point.order), + segment: super::generated_structured_polynomial_point_segment(value.x_point.segment.as_str()), + length: super::generated_structured_polynomial_point_length(value.x_point.length.as_str()), + order: super::generated_structured_polynomial_point_order(value.x_point.order.as_str()), }, y_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { source: super::leak_str(&value.y_point.source), - segment: super::generated_structured_polynomial_point_segment(&value.y_point.segment), - length: super::generated_structured_polynomial_point_length(&value.y_point.length), - order: super::generated_structured_polynomial_point_order(&value.y_point.order), + segment: super::generated_structured_polynomial_point_segment(value.y_point.segment.as_str()), + length: super::generated_structured_polynomial_point_length(value.y_point.length.as_str()), + order: super::generated_structured_polynomial_point_order(value.y_point.order.as_str()), }, }) .collect(), @@ -736,7 +736,7 @@ macro_rules! define_stage_adapter_impl { .iter() .map(|term| bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: term.gamma_power_offset, - function: super::generated_output_function_kind(&term.function), + function: super::generated_output_function_kind(term.function.as_str()), eval: super::leak_str(&term.eval), factors: super::leak_slice( term @@ -751,6 +751,7 @@ macro_rules! define_stage_adapter_impl { }) .collect(), ), + local_scalars: super::leak_str_slice(&plan.local_scalars), claim_value: super::leak_str(&plan.claim_value), }) .collect(), diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index dc4864c836..1ff67da743 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -492,9 +492,7 @@ fn expected_batched_output_claim( program.field_exprs, store, instance, - evals, - &[], - local_point, + evals, &[], &[], local_point, )?; expected += *coefficient * value; } diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 02b83ad96c..5a18ef1b1c 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -469,9 +469,7 @@ fn expected_batched_output_claim( program.field_exprs, store, instance, - evals, - &[], - local_point, + evals, &[], &[], local_point, )?; expected += *coefficient * value; } diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 30793f83ba..080d6c0383 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -727,6 +727,7 @@ fn expected_batched_output_claim( instance, evals, &local_scalars, + &[bolt_verifier_runtime::NamedPoint { symbol: STAGE5_INSTRUCTION_READ_RAF_PLAN.point, point: local_point }], local_point, )? } @@ -737,9 +738,7 @@ fn expected_batched_output_claim( program.field_exprs, store, instance, - evals, - &[], - local_point, + evals, &[], &[], local_point, )? } relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }), diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 60f2f65c60..29459c0ddd 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -99,89 +99,6 @@ const STAGE6_RELATION_SYMBOLS: Stage67RelationSymbols = Stage67RelationSymbols { hamming_booleanity_instance: "stage6.hamming_booleanity.instance", }; -#[rustfmt::skip] -const STAGE6_BYTECODE_RA_EVAL_NAMES: &[&str] = &["stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"]; -const STAGE6_BYTECODE_RA_EVALS: bolt_verifier_runtime::NamedEvalFamilyPlan = bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage6.bytecode_read_raf.eval.BytecodeRa", evals: STAGE6_BYTECODE_RA_EVAL_NAMES }; - -const STAGE6_BYTECODE_STAGE1_TERMS: &[Stage67BytecodeTermPlan] = &[ - Stage67BytecodeTermPlan::Address { gamma_power: 0 }, - Stage67BytecodeTermPlan::Imm { gamma_power: 1 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 0, gamma_power: 2 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 1, gamma_power: 3 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 2, gamma_power: 4 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 3, gamma_power: 5 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 4, gamma_power: 6 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 7 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 8 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 9 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 8, gamma_power: 10 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 9, gamma_power: 11 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 10, gamma_power: 12 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 11, gamma_power: 13 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 14 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 13, gamma_power: 15 }, -]; -const STAGE6_BYTECODE_STAGE2_TERMS: &[Stage67BytecodeTermPlan] = &[ - Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 0 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsBranch, expected: true, gamma_power: 1 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 2 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 3 }, -]; -const STAGE6_BYTECODE_STAGE3_TERMS: &[Stage67BytecodeTermPlan] = &[ - Stage67BytecodeTermPlan::Imm { gamma_power: 0 }, - Stage67BytecodeTermPlan::Address { gamma_power: 1 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsRs1, expected: true, gamma_power: 2 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsPc, expected: true, gamma_power: 3 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsRs2, expected: true, gamma_power: 4 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsImm, expected: true, gamma_power: 5 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsNoop, expected: true, gamma_power: 6 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 7 }, - Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 8 }, -]; -const STAGE6_BYTECODE_STAGE4_TERMS: &[Stage67BytecodeTermPlan] = &[ - Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 }, - Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs1, gamma_power: 1 }, - Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs2, gamma_power: 2 }, -]; -const STAGE6_BYTECODE_STAGE5_TERMS: &[Stage67BytecodeTermPlan] = &[ - Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 }, - Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsInterleaved, expected: false, gamma_power: 1 }, - Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }, -]; -const STAGE6_BYTECODE_STAGES: &[Stage67BytecodeStagePlan] = &[ - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage1_gamma", cycle_point: "stage6.input.stage1.Imm", register_point: None, terms: STAGE6_BYTECODE_STAGE1_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage2_gamma", cycle_point: "stage6.input.stage2.OpFlagJump", register_point: None, terms: STAGE6_BYTECODE_STAGE2_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage3_gamma", cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC", register_point: None, terms: STAGE6_BYTECODE_STAGE3_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage4_gamma", cycle_point: "stage6.input.stage4.Rs1Ra", register_point: Some("stage6.input.stage4.Rs1Ra"), terms: STAGE6_BYTECODE_STAGE4_TERMS }, - Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage5_gamma", cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa", register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"), terms: STAGE6_BYTECODE_STAGE5_TERMS }, -]; - -const STAGE6_BYTECODE_OUTPUT_TERMS: &[Stage67BytecodeOutputTermPlan] = &[ - Stage67BytecodeOutputTermPlan::StageValue { stage_index: 0, gamma_power: 0, identity_gamma_power: Some(5) }, - Stage67BytecodeOutputTermPlan::StageValue { stage_index: 1, gamma_power: 1, identity_gamma_power: None }, - Stage67BytecodeOutputTermPlan::StageValue { stage_index: 2, gamma_power: 2, identity_gamma_power: Some(4) }, - Stage67BytecodeOutputTermPlan::StageValue { stage_index: 3, gamma_power: 3, identity_gamma_power: None }, - Stage67BytecodeOutputTermPlan::StageValue { stage_index: 4, gamma_power: 4, identity_gamma_power: None }, - Stage67BytecodeOutputTermPlan::Entry { gamma_power: 7 }, -]; - -const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { - point: "stage6.bytecode_read_raf.point", - gamma: "stage6.bytecode_read_raf.gamma", - bytecode_ra_evals: &STAGE6_BYTECODE_RA_EVALS, - entries: "stage6.bytecode_read_raf.entries", - entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", - stages: STAGE6_BYTECODE_STAGES, - output_terms: STAGE6_BYTECODE_OUTPUT_TERMS, - output_contribution: "stage6.bytecode_read_raf.output.contribution", - registers: Stage67BytecodeRegisterSymbols { - rd: "stage6.bytecode.entry.rd", - rs1: "stage6.bytecode.entry.rs1", - rs2: "stage6.bytecode.entry.rs2", - }, - entry_lookup_table: "stage6.bytecode.entry.lookup_table", -}; - #[derive(Debug)] pub enum VerifyStage6Error { UnexpectedProofCount { expected: usize, got: usize }, @@ -631,6 +548,89 @@ pub const STAGE6_OPENING_EQUALITIES: &[Stage6OpeningClaimEqualityPlan] = &[ pub const STAGE6_OPENING_BATCHES: &[Stage6OpeningBatchPlan] = &[ Stage6OpeningBatchPlan { symbol: "stage6.openings", stage: "stage6", proof_slot: "stage6.openings", policy: "jolt_stage6_output_order", count: 81, ordered_claims: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"], claim_operands: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"] }, ]; + +#[rustfmt::skip] +const STAGE6_BYTECODE_RA_EVAL_NAMES: &[&str] = &["stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"]; +const STAGE6_BYTECODE_RA_EVALS: bolt_verifier_runtime::NamedEvalFamilyPlan = bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage6.bytecode_read_raf.eval.BytecodeRa", evals: STAGE6_BYTECODE_RA_EVAL_NAMES }; + +const STAGE6_BYTECODE_STAGE1_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::Address { gamma_power: 0 }, + Stage67BytecodeTermPlan::Imm { gamma_power: 1 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 0, gamma_power: 2 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 1, gamma_power: 3 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 2, gamma_power: 4 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 3, gamma_power: 5 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 4, gamma_power: 6 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 7 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 8 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 9 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 8, gamma_power: 10 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 9, gamma_power: 11 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 10, gamma_power: 12 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 11, gamma_power: 13 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 14 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 13, gamma_power: 15 }, +]; +const STAGE6_BYTECODE_STAGE2_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::CircuitFlag { index: 5, gamma_power: 0 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsBranch, expected: true, gamma_power: 1 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 6, gamma_power: 2 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 3 }, +]; +const STAGE6_BYTECODE_STAGE3_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::Imm { gamma_power: 0 }, + Stage67BytecodeTermPlan::Address { gamma_power: 1 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsRs1, expected: true, gamma_power: 2 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::LeftIsPc, expected: true, gamma_power: 3 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsRs2, expected: true, gamma_power: 4 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::RightIsImm, expected: true, gamma_power: 5 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsNoop, expected: true, gamma_power: 6 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 7, gamma_power: 7 }, + Stage67BytecodeTermPlan::CircuitFlag { index: 12, gamma_power: 8 }, +]; +const STAGE6_BYTECODE_STAGE4_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 }, + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs1, gamma_power: 1 }, + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rs2, gamma_power: 2 }, +]; +const STAGE6_BYTECODE_STAGE5_TERMS: &[Stage67BytecodeTermPlan] = &[ + Stage67BytecodeTermPlan::RegisterEq { register: Stage67BytecodeRegister::Rd, gamma_power: 0 }, + Stage67BytecodeTermPlan::EntryFlag { flag: Stage67BytecodeFlag::IsInterleaved, expected: false, gamma_power: 1 }, + Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }, +]; +const STAGE6_BYTECODE_STAGES: &[Stage67BytecodeStagePlan] = &[ + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage1_gamma", cycle_point: "stage6.input.stage1.Imm", register_point: None, terms: STAGE6_BYTECODE_STAGE1_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage2_gamma", cycle_point: "stage6.input.stage2.OpFlagJump", register_point: None, terms: STAGE6_BYTECODE_STAGE2_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage3_gamma", cycle_point: "stage6.input.stage3.spartan_shift.UnexpandedPC", register_point: None, terms: STAGE6_BYTECODE_STAGE3_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage4_gamma", cycle_point: "stage6.input.stage4.Rs1Ra", register_point: Some("stage6.input.stage4.Rs1Ra"), terms: STAGE6_BYTECODE_STAGE4_TERMS }, + Stage67BytecodeStagePlan { gamma: "stage6.bytecode_read_raf.stage5_gamma", cycle_point: "stage6.input.stage5.registers_val_evaluation.RdWa", register_point: Some("stage6.input.stage5.registers_val_evaluation.RdWa"), terms: STAGE6_BYTECODE_STAGE5_TERMS }, +]; + +const STAGE6_BYTECODE_OUTPUT_TERMS: &[Stage67BytecodeOutputTermPlan] = &[ + Stage67BytecodeOutputTermPlan::StageValue { stage_index: 0, gamma_power: 0, identity_gamma_power: Some(5) }, + Stage67BytecodeOutputTermPlan::StageValue { stage_index: 1, gamma_power: 1, identity_gamma_power: None }, + Stage67BytecodeOutputTermPlan::StageValue { stage_index: 2, gamma_power: 2, identity_gamma_power: Some(4) }, + Stage67BytecodeOutputTermPlan::StageValue { stage_index: 3, gamma_power: 3, identity_gamma_power: None }, + Stage67BytecodeOutputTermPlan::StageValue { stage_index: 4, gamma_power: 4, identity_gamma_power: None }, + Stage67BytecodeOutputTermPlan::Entry { gamma_power: 7 }, +]; + +const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { + point: "stage6.bytecode_read_raf.point", + gamma: "stage6.bytecode_read_raf.gamma", + bytecode_ra_evals: &STAGE6_BYTECODE_RA_EVALS, + entries: "stage6.bytecode_read_raf.entries", + entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", + stages: STAGE6_BYTECODE_STAGES, + output_terms: STAGE6_BYTECODE_OUTPUT_TERMS, + output_contribution: "stage6.bytecode_read_raf.output.contribution", + registers: Stage67BytecodeRegisterSymbols { + rd: "stage6.bytecode.entry.rd", + rs1: "stage6.bytecode.entry.rs1", + rs2: "stage6.bytecode.entry.rs2", + }, + entry_lookup_table: "stage6.bytecode.entry.lookup_table", +}; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.booleanity.output.eq.InstructionRa0", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.output.point", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; @@ -1122,7 +1122,7 @@ fn expected_plan_output_claim( instance, evals, local_scalars, - local_point, + &[], local_point, )?) } diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index a54d72e005..5a2671aceb 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -666,9 +666,7 @@ fn expected_batched_output_claim( program.field_exprs, store, instance, - evals, - &[], - local_point, + evals, &[], &[], local_point, )? } relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }), From 8006da7c3978f2af10ad68ccd987ddd3e184fa3a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 10:27:44 -0600 Subject: [PATCH 083/171] refactor(bolt): share verifier plan extraction Centralize Stage 3-7 CPU-row to verifier-plan conversion through a shared stage source trait, leaving stage emitters as thin plan sources. Also clean the Stage 6 bytecode eval-family unit tests so the Bolt clippy gate is warning-clean. --- .../src/protocols/jolt/emit/rust/stage3.rs | 206 +----- .../src/protocols/jolt/emit/rust/stage4.rs | 217 +------ .../src/protocols/jolt/emit/rust/stage5.rs | 217 +------ .../src/protocols/jolt/emit/rust/stage6.rs | 243 +------ .../src/protocols/jolt/emit/rust/stage7.rs | 226 +------ .../bolt/src/protocols/jolt/verifier_plan.rs | 594 ++++++++++++++++++ 6 files changed, 702 insertions(+), 1001 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 1931ca4f76..1f6f4f518e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -222,6 +222,23 @@ pub struct Stage3OpeningBatchPlan { pub claim_operands: Vec, } +verifier_plan::impl_verifier_plan_source_traits!( + program = Stage3CpuProgram, + step = Stage3ProgramStepPlan, + squeeze = Stage3TranscriptSqueezePlan, + opening_input = Stage3OpeningInputPlan, + field_expr = Stage3FieldExprPlan, + claim = Stage3SumcheckClaimPlan, + batch = Stage3SumcheckBatchPlan, + driver = Stage3SumcheckDriverPlan, + instance = Stage3SumcheckInstanceResultPlan, + point_slice = Stage3PointSlicePlan, + point_concat = Stage3PointConcatPlan, + opening_claim = Stage3OpeningClaimPlan, + opening_equality = Stage3OpeningClaimEqualityPlan, + opening_batch = Stage3OpeningBatchPlan, +); + pub fn stage3_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { verify_cpu_schema(module)?; let program = Stage3CpuProgram::from_module(module)?; @@ -605,194 +622,7 @@ impl Stage3CpuProgram { } fn plan_verifier(&self) -> Result { - Ok(VerifierStagePlan { - steps: self - .steps - .iter() - .map(|step| { - verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) - }) - .collect::, EmitError>>()?, - transcript_squeezes: self - .transcript_squeezes - .iter() - .map(|squeeze| { - verifier_plan::VerifierTranscriptSqueezePlan::from_cpu( - &squeeze.symbol, - &squeeze.label, - &squeeze.kind, - squeeze.count, - ) - }) - .collect::, EmitError>>()?, - transcript_absorb_bytes: Vec::new(), - opening_inputs: self - .opening_inputs - .iter() - .map(|input| { - verifier_plan::VerifierOpeningInputPlan::from_cpu( - &input.symbol, - &input.source_stage, - &input.source_claim, - &input.oracle, - &input.domain, - input.point_arity, - &input.claim_kind, - ) - }) - .collect::, EmitError>>()?, - field_exprs: self - .field_exprs - .iter() - .map(|expr| { - verifier_plan::VerifierFieldExprPlan::from_cpu( - &expr.symbol, - &expr.formula, - &expr.operands, - ) - }) - .collect::, EmitError>>()?, - claims: self - .claims - .iter() - .map(|claim| { - Ok(verifier_plan::VerifierSumcheckClaimPlan { - symbol: claim.symbol.clone(), - stage: claim.stage.clone(), - domain: claim.domain.clone(), - num_rounds: claim.num_rounds, - degree: claim.degree, - claim: claim.claim.clone(), - relation: verifier_plan::required_relation_from_cpu( - claim.relation.as_deref(), - "claim", - &claim.symbol, - )?, - claim_value: claim.claim_value.clone(), - }) - }) - .collect::, EmitError>>()?, - batches: self - .batches - .iter() - .map(|batch| verifier_plan::VerifierSumcheckBatchPlan { - symbol: batch.symbol.clone(), - stage: batch.stage.clone(), - proof_slot: batch.proof_slot.clone(), - policy: batch.policy.clone(), - count: batch.count, - claim_operands: batch.claim_operands.clone(), - claim_label: batch.claim_label.clone(), - round_label: batch.round_label.clone(), - round_schedule: batch.round_schedule.clone(), - }) - .collect(), - drivers: self - .drivers - .iter() - .map(|driver| { - Ok(verifier_plan::VerifierSumcheckDriverPlan { - symbol: driver.symbol.clone(), - stage: driver.stage.clone(), - proof_slot: driver.proof_slot.clone(), - relation: verifier_plan::required_relation_from_cpu( - driver.relation.as_deref(), - "driver", - &driver.symbol, - )?, - batch: driver.batch.clone(), - policy: driver.policy.clone(), - round_schedule: driver.round_schedule.clone(), - claim_label: driver.claim_label.clone(), - round_label: driver.round_label.clone(), - num_rounds: driver.num_rounds, - degree: driver.degree, - }) - }) - .collect::, EmitError>>()?, - instance_results: self - .instance_results - .iter() - .map(|instance| { - Ok(verifier_plan::VerifierSumcheckInstanceResultPlan { - symbol: instance.symbol.clone(), - source: instance.source.clone(), - claim: instance.claim.clone(), - relation: verifier_plan::relation_from_cpu(&instance.relation)?, - index: instance.index, - point_arity: instance.point_arity, - num_rounds: instance.num_rounds, - round_offset: instance.round_offset, - point_order: verifier_plan::sumcheck_point_order_from_cpu( - &instance.point_order, - )?, - degree: instance.degree, - }) - }) - .collect::, EmitError>>()?, - point_zeros: Vec::new(), - point_slices: self - .point_slices - .iter() - .map(|slice| verifier_plan::VerifierPointSlicePlan { - symbol: slice.symbol.clone(), - source: slice.source.clone(), - offset: slice.offset, - length: slice.length, - input: slice.input.clone(), - }) - .collect(), - point_concats: self - .point_concats - .iter() - .map(|concat| verifier_plan::VerifierPointConcatPlan { - symbol: concat.symbol.clone(), - layout: concat.layout.clone(), - arity: concat.arity, - inputs: concat.inputs.clone(), - }) - .collect(), - opening_claims: self - .opening_claims - .iter() - .map(|claim| { - Ok(verifier_plan::VerifierOpeningClaimPlan { - symbol: claim.symbol.clone(), - oracle: claim.oracle.clone(), - domain: claim.domain.clone(), - point_arity: claim.point_arity, - claim_kind: verifier_plan::claim_kind_from_cpu(&claim.claim_kind)?, - point_source: claim.point_source.clone(), - eval_source: claim.eval_source.clone(), - }) - }) - .collect::, EmitError>>()?, - opening_equalities: self - .opening_equalities - .iter() - .map(|equality| { - Ok(verifier_plan::VerifierOpeningClaimEqualityPlan { - symbol: equality.symbol.clone(), - mode: verifier_plan::opening_equality_mode_from_cpu(&equality.mode)?, - lhs: equality.lhs.clone(), - rhs: equality.rhs.clone(), - }) - }) - .collect::, EmitError>>()?, - opening_batches: self - .opening_batches - .iter() - .map(|batch| verifier_plan::VerifierOpeningBatchPlan { - symbol: batch.symbol.clone(), - stage: batch.stage.clone(), - proof_slot: batch.proof_slot.clone(), - policy: batch.policy.clone(), - count: batch.count, - ordered_claims: batch.ordered_claims.clone(), - claim_operands: batch.claim_operands.clone(), - }) - .collect(), - }) + verifier_plan::stage_plan_from_cpu_sources(self) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 9920186c70..d9148f8cea 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -235,6 +235,24 @@ pub struct Stage4OpeningBatchPlan { pub claim_operands: Vec, } +verifier_plan::impl_verifier_plan_source_traits!( + program = Stage4CpuProgram, + step = Stage4ProgramStepPlan, + squeeze = Stage4TranscriptSqueezePlan, + opening_input = Stage4OpeningInputPlan, + field_expr = Stage4FieldExprPlan, + claim = Stage4SumcheckClaimPlan, + batch = Stage4SumcheckBatchPlan, + driver = Stage4SumcheckDriverPlan, + instance = Stage4SumcheckInstanceResultPlan, + point_slice = Stage4PointSlicePlan, + point_concat = Stage4PointConcatPlan, + opening_claim = Stage4OpeningClaimPlan, + opening_equality = Stage4OpeningClaimEqualityPlan, + opening_batch = Stage4OpeningBatchPlan, + absorb = Stage4TranscriptAbsorbBytesPlan, +); + pub fn stage4_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { verify_cpu_schema(module)?; let program = Stage4CpuProgram::from_module(module)?; @@ -617,204 +635,7 @@ impl Stage4CpuProgram { } fn plan_verifier(&self) -> Result { - Ok(VerifierStagePlan { - steps: self - .steps - .iter() - .map(|step| { - verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) - }) - .collect::, EmitError>>()?, - transcript_squeezes: self - .transcript_squeezes - .iter() - .map(|squeeze| { - verifier_plan::VerifierTranscriptSqueezePlan::from_cpu( - &squeeze.symbol, - &squeeze.label, - &squeeze.kind, - squeeze.count, - ) - }) - .collect::, EmitError>>()?, - transcript_absorb_bytes: self - .transcript_absorb_bytes - .iter() - .map(|absorb| { - verifier_plan::VerifierTranscriptAbsorbBytesPlan::from_cpu( - &absorb.symbol, - &absorb.label, - &absorb.payload, - ) - }) - .collect(), - opening_inputs: self - .opening_inputs - .iter() - .map(|input| { - verifier_plan::VerifierOpeningInputPlan::from_cpu( - &input.symbol, - &input.source_stage, - &input.source_claim, - &input.oracle, - &input.domain, - input.point_arity, - &input.claim_kind, - ) - }) - .collect::, EmitError>>()?, - field_exprs: self - .field_exprs - .iter() - .map(|expr| { - verifier_plan::VerifierFieldExprPlan::from_cpu( - &expr.symbol, - &expr.formula, - &expr.operands, - ) - }) - .collect::, EmitError>>()?, - claims: self - .claims - .iter() - .map(|claim| { - Ok(verifier_plan::VerifierSumcheckClaimPlan { - symbol: claim.symbol.clone(), - stage: claim.stage.clone(), - domain: claim.domain.clone(), - num_rounds: claim.num_rounds, - degree: claim.degree, - claim: claim.claim.clone(), - relation: verifier_plan::required_relation_from_cpu( - claim.relation.as_deref(), - "claim", - &claim.symbol, - )?, - claim_value: claim.claim_value.clone(), - }) - }) - .collect::, EmitError>>()?, - batches: self - .batches - .iter() - .map(|batch| verifier_plan::VerifierSumcheckBatchPlan { - symbol: batch.symbol.clone(), - stage: batch.stage.clone(), - proof_slot: batch.proof_slot.clone(), - policy: batch.policy.clone(), - count: batch.count, - claim_operands: batch.claim_operands.clone(), - claim_label: batch.claim_label.clone(), - round_label: batch.round_label.clone(), - round_schedule: batch.round_schedule.clone(), - }) - .collect(), - drivers: self - .drivers - .iter() - .map(|driver| { - Ok(verifier_plan::VerifierSumcheckDriverPlan { - symbol: driver.symbol.clone(), - stage: driver.stage.clone(), - proof_slot: driver.proof_slot.clone(), - relation: verifier_plan::required_relation_from_cpu( - driver.relation.as_deref(), - "driver", - &driver.symbol, - )?, - batch: driver.batch.clone(), - policy: driver.policy.clone(), - round_schedule: driver.round_schedule.clone(), - claim_label: driver.claim_label.clone(), - round_label: driver.round_label.clone(), - num_rounds: driver.num_rounds, - degree: driver.degree, - }) - }) - .collect::, EmitError>>()?, - instance_results: self - .instance_results - .iter() - .map(|instance| { - Ok(verifier_plan::VerifierSumcheckInstanceResultPlan { - symbol: instance.symbol.clone(), - source: instance.source.clone(), - claim: instance.claim.clone(), - relation: verifier_plan::relation_from_cpu(&instance.relation)?, - index: instance.index, - point_arity: instance.point_arity, - num_rounds: instance.num_rounds, - round_offset: instance.round_offset, - point_order: verifier_plan::sumcheck_point_order_from_cpu( - &instance.point_order, - )?, - degree: instance.degree, - }) - }) - .collect::, EmitError>>()?, - point_zeros: Vec::new(), - point_slices: self - .point_slices - .iter() - .map(|slice| verifier_plan::VerifierPointSlicePlan { - symbol: slice.symbol.clone(), - source: slice.source.clone(), - offset: slice.offset, - length: slice.length, - input: slice.input.clone(), - }) - .collect(), - point_concats: self - .point_concats - .iter() - .map(|concat| verifier_plan::VerifierPointConcatPlan { - symbol: concat.symbol.clone(), - layout: concat.layout.clone(), - arity: concat.arity, - inputs: concat.inputs.clone(), - }) - .collect(), - opening_claims: self - .opening_claims - .iter() - .map(|claim| { - Ok(verifier_plan::VerifierOpeningClaimPlan { - symbol: claim.symbol.clone(), - oracle: claim.oracle.clone(), - domain: claim.domain.clone(), - point_arity: claim.point_arity, - claim_kind: verifier_plan::claim_kind_from_cpu(&claim.claim_kind)?, - point_source: claim.point_source.clone(), - eval_source: claim.eval_source.clone(), - }) - }) - .collect::, EmitError>>()?, - opening_equalities: self - .opening_equalities - .iter() - .map(|equality| { - Ok(verifier_plan::VerifierOpeningClaimEqualityPlan { - symbol: equality.symbol.clone(), - mode: verifier_plan::opening_equality_mode_from_cpu(&equality.mode)?, - lhs: equality.lhs.clone(), - rhs: equality.rhs.clone(), - }) - }) - .collect::, EmitError>>()?, - opening_batches: self - .opening_batches - .iter() - .map(|batch| verifier_plan::VerifierOpeningBatchPlan { - symbol: batch.symbol.clone(), - stage: batch.stage.clone(), - proof_slot: batch.proof_slot.clone(), - policy: batch.policy.clone(), - count: batch.count, - ordered_claims: batch.ordered_claims.clone(), - claim_operands: batch.claim_operands.clone(), - }) - .collect(), - }) + verifier_plan::stage_plan_from_cpu_sources(self) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index da2b9d2bd3..62c02e6416 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -256,6 +256,24 @@ pub struct Stage5OpeningBatchPlan { pub claim_operands: Vec, } +verifier_plan::impl_verifier_plan_source_traits!( + program = Stage5CpuProgram, + step = Stage5ProgramStepPlan, + squeeze = Stage5TranscriptSqueezePlan, + opening_input = Stage5OpeningInputPlan, + field_expr = Stage5FieldExprPlan, + claim = Stage5SumcheckClaimPlan, + batch = Stage5SumcheckBatchPlan, + driver = Stage5SumcheckDriverPlan, + instance = Stage5SumcheckInstanceResultPlan, + point_slice = Stage5PointSlicePlan, + point_concat = Stage5PointConcatPlan, + opening_claim = Stage5OpeningClaimPlan, + opening_equality = Stage5OpeningClaimEqualityPlan, + opening_batch = Stage5OpeningBatchPlan, + absorb = Stage5TranscriptAbsorbBytesPlan, +); + pub fn stage5_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { verify_cpu_schema(module)?; let program = Stage5CpuProgram::from_module(module)?; @@ -668,204 +686,7 @@ impl Stage5CpuProgram { } fn plan_verifier(&self) -> Result { - Ok(VerifierStagePlan { - steps: self - .steps - .iter() - .map(|step| { - verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) - }) - .collect::, EmitError>>()?, - transcript_squeezes: self - .transcript_squeezes - .iter() - .map(|squeeze| { - verifier_plan::VerifierTranscriptSqueezePlan::from_cpu( - &squeeze.symbol, - &squeeze.label, - &squeeze.kind, - squeeze.count, - ) - }) - .collect::, EmitError>>()?, - transcript_absorb_bytes: self - .transcript_absorb_bytes - .iter() - .map(|absorb| { - verifier_plan::VerifierTranscriptAbsorbBytesPlan::from_cpu( - &absorb.symbol, - &absorb.label, - &absorb.payload, - ) - }) - .collect(), - opening_inputs: self - .opening_inputs - .iter() - .map(|input| { - verifier_plan::VerifierOpeningInputPlan::from_cpu( - &input.symbol, - &input.source_stage, - &input.source_claim, - &input.oracle, - &input.domain, - input.point_arity, - &input.claim_kind, - ) - }) - .collect::, EmitError>>()?, - field_exprs: self - .field_exprs - .iter() - .map(|expr| { - verifier_plan::VerifierFieldExprPlan::from_cpu( - &expr.symbol, - &expr.formula, - &expr.operands, - ) - }) - .collect::, EmitError>>()?, - claims: self - .claims - .iter() - .map(|claim| { - Ok(verifier_plan::VerifierSumcheckClaimPlan { - symbol: claim.symbol.clone(), - stage: claim.stage.clone(), - domain: claim.domain.clone(), - num_rounds: claim.num_rounds, - degree: claim.degree, - claim: claim.claim.clone(), - relation: verifier_plan::required_relation_from_cpu( - claim.relation.as_deref(), - "claim", - &claim.symbol, - )?, - claim_value: claim.claim_value.clone(), - }) - }) - .collect::, EmitError>>()?, - batches: self - .batches - .iter() - .map(|batch| verifier_plan::VerifierSumcheckBatchPlan { - symbol: batch.symbol.clone(), - stage: batch.stage.clone(), - proof_slot: batch.proof_slot.clone(), - policy: batch.policy.clone(), - count: batch.count, - claim_operands: batch.claim_operands.clone(), - claim_label: batch.claim_label.clone(), - round_label: batch.round_label.clone(), - round_schedule: batch.round_schedule.clone(), - }) - .collect(), - drivers: self - .drivers - .iter() - .map(|driver| { - Ok(verifier_plan::VerifierSumcheckDriverPlan { - symbol: driver.symbol.clone(), - stage: driver.stage.clone(), - proof_slot: driver.proof_slot.clone(), - relation: verifier_plan::required_relation_from_cpu( - driver.relation.as_deref(), - "driver", - &driver.symbol, - )?, - batch: driver.batch.clone(), - policy: driver.policy.clone(), - round_schedule: driver.round_schedule.clone(), - claim_label: driver.claim_label.clone(), - round_label: driver.round_label.clone(), - num_rounds: driver.num_rounds, - degree: driver.degree, - }) - }) - .collect::, EmitError>>()?, - instance_results: self - .instance_results - .iter() - .map(|instance| { - Ok(verifier_plan::VerifierSumcheckInstanceResultPlan { - symbol: instance.symbol.clone(), - source: instance.source.clone(), - claim: instance.claim.clone(), - relation: verifier_plan::relation_from_cpu(&instance.relation)?, - index: instance.index, - point_arity: instance.point_arity, - num_rounds: instance.num_rounds, - round_offset: instance.round_offset, - point_order: verifier_plan::sumcheck_point_order_from_cpu( - &instance.point_order, - )?, - degree: instance.degree, - }) - }) - .collect::, EmitError>>()?, - point_zeros: Vec::new(), - point_slices: self - .point_slices - .iter() - .map(|slice| verifier_plan::VerifierPointSlicePlan { - symbol: slice.symbol.clone(), - source: slice.source.clone(), - offset: slice.offset, - length: slice.length, - input: slice.input.clone(), - }) - .collect(), - point_concats: self - .point_concats - .iter() - .map(|concat| verifier_plan::VerifierPointConcatPlan { - symbol: concat.symbol.clone(), - layout: concat.layout.clone(), - arity: concat.arity, - inputs: concat.inputs.clone(), - }) - .collect(), - opening_claims: self - .opening_claims - .iter() - .map(|claim| { - Ok(verifier_plan::VerifierOpeningClaimPlan { - symbol: claim.symbol.clone(), - oracle: claim.oracle.clone(), - domain: claim.domain.clone(), - point_arity: claim.point_arity, - claim_kind: verifier_plan::claim_kind_from_cpu(&claim.claim_kind)?, - point_source: claim.point_source.clone(), - eval_source: claim.eval_source.clone(), - }) - }) - .collect::, EmitError>>()?, - opening_equalities: self - .opening_equalities - .iter() - .map(|equality| { - Ok(verifier_plan::VerifierOpeningClaimEqualityPlan { - symbol: equality.symbol.clone(), - mode: verifier_plan::opening_equality_mode_from_cpu(&equality.mode)?, - lhs: equality.lhs.clone(), - rhs: equality.rhs.clone(), - }) - }) - .collect::, EmitError>>()?, - opening_batches: self - .opening_batches - .iter() - .map(|batch| verifier_plan::VerifierOpeningBatchPlan { - symbol: batch.symbol.clone(), - stage: batch.stage.clone(), - proof_slot: batch.proof_slot.clone(), - policy: batch.policy.clone(), - count: batch.count, - ordered_claims: batch.ordered_claims.clone(), - claim_operands: batch.claim_operands.clone(), - }) - .collect(), - }) + verifier_plan::stage_plan_from_cpu_sources(self) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 2b7aff8bf8..20d7801579 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -280,6 +280,25 @@ pub struct Stage6OpeningBatchPlan { pub claim_operands: Vec, } +verifier_plan::impl_verifier_plan_source_traits!( + program = Stage6CpuProgram, + step = Stage6ProgramStepPlan, + squeeze = Stage6TranscriptSqueezePlan, + opening_input = Stage6OpeningInputPlan, + field_expr = Stage6FieldExprPlan, + claim = Stage6SumcheckClaimPlan, + batch = Stage6SumcheckBatchPlan, + driver = Stage6SumcheckDriverPlan, + instance = Stage6SumcheckInstanceResultPlan, + point_slice = Stage6PointSlicePlan, + point_concat = Stage6PointConcatPlan, + opening_claim = Stage6OpeningClaimPlan, + opening_equality = Stage6OpeningClaimEqualityPlan, + opening_batch = Stage6OpeningBatchPlan, + absorb = Stage6TranscriptAbsorbBytesPlan, + point_zero = Stage6PointZeroPlan, +); + pub fn stage6_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { verify_cpu_schema(module)?; let program = Stage6CpuProgram::from_module(module)?; @@ -692,212 +711,7 @@ impl Stage6CpuProgram { } fn plan_verifier(&self) -> Result { - Ok(VerifierStagePlan { - steps: self - .steps - .iter() - .map(|step| { - verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) - }) - .collect::, EmitError>>()?, - transcript_squeezes: self - .transcript_squeezes - .iter() - .map(|squeeze| { - verifier_plan::VerifierTranscriptSqueezePlan::from_cpu( - &squeeze.symbol, - &squeeze.label, - &squeeze.kind, - squeeze.count, - ) - }) - .collect::, EmitError>>()?, - transcript_absorb_bytes: self - .transcript_absorb_bytes - .iter() - .map(|absorb| { - verifier_plan::VerifierTranscriptAbsorbBytesPlan::from_cpu( - &absorb.symbol, - &absorb.label, - &absorb.payload, - ) - }) - .collect(), - opening_inputs: self - .opening_inputs - .iter() - .map(|input| { - verifier_plan::VerifierOpeningInputPlan::from_cpu( - &input.symbol, - &input.source_stage, - &input.source_claim, - &input.oracle, - &input.domain, - input.point_arity, - &input.claim_kind, - ) - }) - .collect::, EmitError>>()?, - field_exprs: self - .field_exprs - .iter() - .map(|expr| { - verifier_plan::VerifierFieldExprPlan::from_cpu( - &expr.symbol, - &expr.formula, - &expr.operands, - ) - }) - .collect::, EmitError>>()?, - claims: self - .claims - .iter() - .map(|claim| { - Ok(verifier_plan::VerifierSumcheckClaimPlan { - symbol: claim.symbol.clone(), - stage: claim.stage.clone(), - domain: claim.domain.clone(), - num_rounds: claim.num_rounds, - degree: claim.degree, - claim: claim.claim.clone(), - relation: verifier_plan::required_relation_from_cpu( - claim.relation.as_deref(), - "claim", - &claim.symbol, - )?, - claim_value: claim.claim_value.clone(), - }) - }) - .collect::, EmitError>>()?, - batches: self - .batches - .iter() - .map(|batch| verifier_plan::VerifierSumcheckBatchPlan { - symbol: batch.symbol.clone(), - stage: batch.stage.clone(), - proof_slot: batch.proof_slot.clone(), - policy: batch.policy.clone(), - count: batch.count, - claim_operands: batch.claim_operands.clone(), - claim_label: batch.claim_label.clone(), - round_label: batch.round_label.clone(), - round_schedule: batch.round_schedule.clone(), - }) - .collect(), - drivers: self - .drivers - .iter() - .map(|driver| { - Ok(verifier_plan::VerifierSumcheckDriverPlan { - symbol: driver.symbol.clone(), - stage: driver.stage.clone(), - proof_slot: driver.proof_slot.clone(), - relation: verifier_plan::required_relation_from_cpu( - driver.relation.as_deref(), - "driver", - &driver.symbol, - )?, - batch: driver.batch.clone(), - policy: driver.policy.clone(), - round_schedule: driver.round_schedule.clone(), - claim_label: driver.claim_label.clone(), - round_label: driver.round_label.clone(), - num_rounds: driver.num_rounds, - degree: driver.degree, - }) - }) - .collect::, EmitError>>()?, - instance_results: self - .instance_results - .iter() - .map(|instance| { - Ok(verifier_plan::VerifierSumcheckInstanceResultPlan { - symbol: instance.symbol.clone(), - source: instance.source.clone(), - claim: instance.claim.clone(), - relation: verifier_plan::relation_from_cpu(&instance.relation)?, - index: instance.index, - point_arity: instance.point_arity, - num_rounds: instance.num_rounds, - round_offset: instance.round_offset, - point_order: verifier_plan::sumcheck_point_order_from_cpu( - &instance.point_order, - )?, - degree: instance.degree, - }) - }) - .collect::, EmitError>>()?, - point_zeros: self - .point_zeros - .iter() - .map(|zero| verifier_plan::VerifierPointZeroPlan { - symbol: zero.symbol.clone(), - field: zero.field.clone(), - arity: zero.arity, - }) - .collect(), - point_slices: self - .point_slices - .iter() - .map(|slice| verifier_plan::VerifierPointSlicePlan { - symbol: slice.symbol.clone(), - source: slice.source.clone(), - offset: slice.offset, - length: slice.length, - input: slice.input.clone(), - }) - .collect(), - point_concats: self - .point_concats - .iter() - .map(|concat| verifier_plan::VerifierPointConcatPlan { - symbol: concat.symbol.clone(), - layout: concat.layout.clone(), - arity: concat.arity, - inputs: concat.inputs.clone(), - }) - .collect(), - opening_claims: self - .opening_claims - .iter() - .map(|claim| { - Ok(verifier_plan::VerifierOpeningClaimPlan { - symbol: claim.symbol.clone(), - oracle: claim.oracle.clone(), - domain: claim.domain.clone(), - point_arity: claim.point_arity, - claim_kind: verifier_plan::claim_kind_from_cpu(&claim.claim_kind)?, - point_source: claim.point_source.clone(), - eval_source: claim.eval_source.clone(), - }) - }) - .collect::, EmitError>>()?, - opening_equalities: self - .opening_equalities - .iter() - .map(|equality| { - Ok(verifier_plan::VerifierOpeningClaimEqualityPlan { - symbol: equality.symbol.clone(), - mode: verifier_plan::opening_equality_mode_from_cpu(&equality.mode)?, - lhs: equality.lhs.clone(), - rhs: equality.rhs.clone(), - }) - }) - .collect::, EmitError>>()?, - opening_batches: self - .opening_batches - .iter() - .map(|batch| verifier_plan::VerifierOpeningBatchPlan { - symbol: batch.symbol.clone(), - stage: batch.stage.clone(), - proof_slot: batch.proof_slot.clone(), - policy: batch.policy.clone(), - count: batch.count, - ordered_claims: batch.ordered_claims.clone(), - claim_operands: batch.claim_operands.clone(), - }) - .collect(), - }) + verifier_plan::stage_plan_from_cpu_sources(self) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { @@ -3073,6 +2887,8 @@ fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { #[cfg(test)] mod tests { + use crate::emit::rust::EmitError; + use super::{ stage6_bytecode_read_raf_eval_names, stage6_kernel_abi, Stage6SumcheckEvalPlan, STAGE6_KERNEL_ABIS, @@ -3093,7 +2909,7 @@ mod tests { } #[test] - fn stage6_bytecode_read_raf_eval_family_is_sorted_by_suffix() { + fn stage6_bytecode_read_raf_eval_family_is_sorted_by_suffix() -> Result<(), EmitError> { let evals = vec![ eval("stage6.bytecode_read_raf.eval.BytecodeRa_2"), eval("stage6.booleanity.eval.BytecodeRa_0"), @@ -3101,14 +2917,16 @@ mod tests { eval("stage6.bytecode_read_raf.eval.BytecodeRa_1"), ]; + let names = stage6_bytecode_read_raf_eval_names(&evals)?; assert_eq!( - stage6_bytecode_read_raf_eval_names(&evals).unwrap(), + names, vec![ "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(), ] ); + Ok(()) } #[test] @@ -3118,9 +2936,12 @@ mod tests { eval("stage6.bytecode_read_raf.eval.BytecodeRa_2"), ]; - let error = stage6_bytecode_read_raf_eval_names(&evals) - .unwrap_err() - .to_string(); + let result = stage6_bytecode_read_raf_eval_names(&evals); + assert!(result.is_err(), "expected gap error, got {result:?}"); + let error = result + .err() + .map(|error| error.to_string()) + .unwrap_or_default(); assert!(error.contains("not contiguous")); } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 24798d5b12..bff3b71f17 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -263,6 +263,25 @@ pub struct Stage7OpeningBatchPlan { pub claim_operands: Vec, } +verifier_plan::impl_verifier_plan_source_traits!( + program = Stage7CpuProgram, + step = Stage7ProgramStepPlan, + squeeze = Stage7TranscriptSqueezePlan, + opening_input = Stage7OpeningInputPlan, + field_expr = Stage7FieldExprPlan, + claim = Stage7SumcheckClaimPlan, + batch = Stage7SumcheckBatchPlan, + driver = Stage7SumcheckDriverPlan, + instance = Stage7SumcheckInstanceResultPlan, + point_slice = Stage7PointSlicePlan, + point_concat = Stage7PointConcatPlan, + opening_claim = Stage7OpeningClaimPlan, + opening_equality = Stage7OpeningClaimEqualityPlan, + opening_batch = Stage7OpeningBatchPlan, + absorb = Stage7TranscriptAbsorbBytesPlan, + point_zero = Stage7PointZeroPlan, +); + pub fn stage7_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { verify_cpu_schema(module)?; let program = Stage7CpuProgram::from_module(module)?; @@ -669,212 +688,7 @@ impl Stage7CpuProgram { } fn plan_verifier(&self) -> Result { - Ok(VerifierStagePlan { - steps: self - .steps - .iter() - .map(|step| { - verifier_plan::VerifierProgramStepPlan::from_cpu(&step.kind, &step.symbol) - }) - .collect::, EmitError>>()?, - transcript_squeezes: self - .transcript_squeezes - .iter() - .map(|squeeze| { - verifier_plan::VerifierTranscriptSqueezePlan::from_cpu( - &squeeze.symbol, - &squeeze.label, - &squeeze.kind, - squeeze.count, - ) - }) - .collect::, EmitError>>()?, - transcript_absorb_bytes: self - .transcript_absorb_bytes - .iter() - .map(|absorb| { - verifier_plan::VerifierTranscriptAbsorbBytesPlan::from_cpu( - &absorb.symbol, - &absorb.label, - &absorb.payload, - ) - }) - .collect(), - opening_inputs: self - .opening_inputs - .iter() - .map(|input| { - verifier_plan::VerifierOpeningInputPlan::from_cpu( - &input.symbol, - &input.source_stage, - &input.source_claim, - &input.oracle, - &input.domain, - input.point_arity, - &input.claim_kind, - ) - }) - .collect::, EmitError>>()?, - field_exprs: self - .field_exprs - .iter() - .map(|expr| { - verifier_plan::VerifierFieldExprPlan::from_cpu( - &expr.symbol, - &expr.formula, - &expr.operands, - ) - }) - .collect::, EmitError>>()?, - claims: self - .claims - .iter() - .map(|claim| { - Ok(verifier_plan::VerifierSumcheckClaimPlan { - symbol: claim.symbol.clone(), - stage: claim.stage.clone(), - domain: claim.domain.clone(), - num_rounds: claim.num_rounds, - degree: claim.degree, - claim: claim.claim.clone(), - relation: verifier_plan::required_relation_from_cpu( - claim.relation.as_deref(), - "claim", - &claim.symbol, - )?, - claim_value: claim.claim_value.clone(), - }) - }) - .collect::, EmitError>>()?, - batches: self - .batches - .iter() - .map(|batch| verifier_plan::VerifierSumcheckBatchPlan { - symbol: batch.symbol.clone(), - stage: batch.stage.clone(), - proof_slot: batch.proof_slot.clone(), - policy: batch.policy.clone(), - count: batch.count, - claim_operands: batch.claim_operands.clone(), - claim_label: batch.claim_label.clone(), - round_label: batch.round_label.clone(), - round_schedule: batch.round_schedule.clone(), - }) - .collect(), - drivers: self - .drivers - .iter() - .map(|driver| { - Ok(verifier_plan::VerifierSumcheckDriverPlan { - symbol: driver.symbol.clone(), - stage: driver.stage.clone(), - proof_slot: driver.proof_slot.clone(), - relation: verifier_plan::required_relation_from_cpu( - driver.relation.as_deref(), - "driver", - &driver.symbol, - )?, - batch: driver.batch.clone(), - policy: driver.policy.clone(), - round_schedule: driver.round_schedule.clone(), - claim_label: driver.claim_label.clone(), - round_label: driver.round_label.clone(), - num_rounds: driver.num_rounds, - degree: driver.degree, - }) - }) - .collect::, EmitError>>()?, - instance_results: self - .instance_results - .iter() - .map(|instance| { - Ok(verifier_plan::VerifierSumcheckInstanceResultPlan { - symbol: instance.symbol.clone(), - source: instance.source.clone(), - claim: instance.claim.clone(), - relation: verifier_plan::relation_from_cpu(&instance.relation)?, - index: instance.index, - point_arity: instance.point_arity, - num_rounds: instance.num_rounds, - round_offset: instance.round_offset, - point_order: verifier_plan::sumcheck_point_order_from_cpu( - &instance.point_order, - )?, - degree: instance.degree, - }) - }) - .collect::, EmitError>>()?, - point_zeros: self - .point_zeros - .iter() - .map(|zero| verifier_plan::VerifierPointZeroPlan { - symbol: zero.symbol.clone(), - field: zero.field.clone(), - arity: zero.arity, - }) - .collect(), - point_slices: self - .point_slices - .iter() - .map(|slice| verifier_plan::VerifierPointSlicePlan { - symbol: slice.symbol.clone(), - source: slice.source.clone(), - offset: slice.offset, - length: slice.length, - input: slice.input.clone(), - }) - .collect(), - point_concats: self - .point_concats - .iter() - .map(|concat| verifier_plan::VerifierPointConcatPlan { - symbol: concat.symbol.clone(), - layout: concat.layout.clone(), - arity: concat.arity, - inputs: concat.inputs.clone(), - }) - .collect(), - opening_claims: self - .opening_claims - .iter() - .map(|claim| { - Ok(verifier_plan::VerifierOpeningClaimPlan { - symbol: claim.symbol.clone(), - oracle: claim.oracle.clone(), - domain: claim.domain.clone(), - point_arity: claim.point_arity, - claim_kind: verifier_plan::claim_kind_from_cpu(&claim.claim_kind)?, - point_source: claim.point_source.clone(), - eval_source: claim.eval_source.clone(), - }) - }) - .collect::, EmitError>>()?, - opening_equalities: self - .opening_equalities - .iter() - .map(|equality| { - Ok(verifier_plan::VerifierOpeningClaimEqualityPlan { - symbol: equality.symbol.clone(), - mode: verifier_plan::opening_equality_mode_from_cpu(&equality.mode)?, - lhs: equality.lhs.clone(), - rhs: equality.rhs.clone(), - }) - }) - .collect::, EmitError>>()?, - opening_batches: self - .opening_batches - .iter() - .map(|batch| verifier_plan::VerifierOpeningBatchPlan { - symbol: batch.symbol.clone(), - stage: batch.stage.clone(), - proof_slot: batch.proof_slot.clone(), - policy: batch.policy.clone(), - count: batch.count, - ordered_claims: batch.ordered_claims.clone(), - claim_operands: batch.claim_operands.clone(), - }) - .collect(), - }) + verifier_plan::stage_plan_from_cpu_sources(self) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 1bb8d6bdca..31c3691d47 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -243,6 +243,600 @@ pub(crate) struct VerifierStagePlan { pub(crate) opening_batches: Vec, } +pub(crate) trait VerifierProgramStepSource { + fn kind(&self) -> &str; + fn symbol(&self) -> &str; +} + +pub(crate) trait VerifierTranscriptSqueezeSource { + fn symbol(&self) -> &str; + fn label(&self) -> &str; + fn kind(&self) -> &str; + fn count(&self) -> usize; +} + +pub(crate) trait VerifierTranscriptAbsorbBytesSource { + fn symbol(&self) -> &str; + fn label(&self) -> &str; + fn payload(&self) -> &str; +} + +pub(crate) trait VerifierOpeningInputSource { + fn symbol(&self) -> &str; + fn source_stage(&self) -> &str; + fn source_claim(&self) -> &str; + fn oracle(&self) -> &str; + fn domain(&self) -> &str; + fn point_arity(&self) -> usize; + fn claim_kind(&self) -> &str; +} + +pub(crate) trait VerifierFieldExprSource { + fn symbol(&self) -> &str; + fn formula(&self) -> &str; + fn operands(&self) -> &[String]; +} + +pub(crate) trait VerifierSumcheckClaimSource { + fn symbol(&self) -> &str; + fn stage(&self) -> &str; + fn domain(&self) -> &str; + fn num_rounds(&self) -> usize; + fn degree(&self) -> usize; + fn claim(&self) -> &str; + fn relation(&self) -> Option<&str>; + fn claim_value(&self) -> &str; +} + +pub(crate) trait VerifierSumcheckBatchSource { + fn symbol(&self) -> &str; + fn stage(&self) -> &str; + fn proof_slot(&self) -> &str; + fn policy(&self) -> &str; + fn count(&self) -> usize; + fn claim_operands(&self) -> &[String]; + fn claim_label(&self) -> &str; + fn round_label(&self) -> &str; + fn round_schedule(&self) -> &[usize]; +} + +pub(crate) trait VerifierSumcheckDriverSource { + fn symbol(&self) -> &str; + fn stage(&self) -> &str; + fn proof_slot(&self) -> &str; + fn relation(&self) -> Option<&str>; + fn batch(&self) -> &str; + fn policy(&self) -> &str; + fn round_schedule(&self) -> &[usize]; + fn claim_label(&self) -> &str; + fn round_label(&self) -> &str; + fn num_rounds(&self) -> usize; + fn degree(&self) -> usize; +} + +pub(crate) trait VerifierSumcheckInstanceResultSource { + fn symbol(&self) -> &str; + fn source(&self) -> &str; + fn claim(&self) -> &str; + fn relation(&self) -> &str; + fn index(&self) -> usize; + fn point_arity(&self) -> usize; + fn num_rounds(&self) -> usize; + fn round_offset(&self) -> usize; + fn point_order(&self) -> &str; + fn degree(&self) -> usize; +} + +pub(crate) trait VerifierPointZeroSource { + fn symbol(&self) -> &str; + fn field(&self) -> &str; + fn arity(&self) -> usize; +} + +pub(crate) trait VerifierPointSliceSource { + fn symbol(&self) -> &str; + fn source(&self) -> &str; + fn offset(&self) -> usize; + fn length(&self) -> usize; + fn input(&self) -> &str; +} + +pub(crate) trait VerifierPointConcatSource { + fn symbol(&self) -> &str; + fn layout(&self) -> &str; + fn arity(&self) -> usize; + fn inputs(&self) -> &[String]; +} + +pub(crate) trait VerifierOpeningClaimSource { + fn symbol(&self) -> &str; + fn oracle(&self) -> &str; + fn domain(&self) -> &str; + fn point_arity(&self) -> usize; + fn claim_kind(&self) -> &str; + fn point_source(&self) -> &str; + fn eval_source(&self) -> &str; +} + +pub(crate) trait VerifierOpeningClaimEqualitySource { + fn symbol(&self) -> &str; + fn mode(&self) -> &str; + fn lhs(&self) -> &str; + fn rhs(&self) -> &str; +} + +pub(crate) trait VerifierOpeningBatchSource { + fn symbol(&self) -> &str; + fn stage(&self) -> &str; + fn proof_slot(&self) -> &str; + fn policy(&self) -> &str; + fn count(&self) -> usize; + fn ordered_claims(&self) -> &[String]; + fn claim_operands(&self) -> &[String]; +} + +pub(crate) trait VerifierStagePlanSource { + type Step: VerifierProgramStepSource; + type Squeeze: VerifierTranscriptSqueezeSource; + type OpeningInput: VerifierOpeningInputSource; + type FieldExpr: VerifierFieldExprSource; + type Claim: VerifierSumcheckClaimSource; + type Batch: VerifierSumcheckBatchSource; + type Driver: VerifierSumcheckDriverSource; + type Instance: VerifierSumcheckInstanceResultSource; + type PointSlice: VerifierPointSliceSource; + type PointConcat: VerifierPointConcatSource; + type OpeningClaim: VerifierOpeningClaimSource; + type OpeningEquality: VerifierOpeningClaimEqualitySource; + type OpeningBatch: VerifierOpeningBatchSource; + + fn steps(&self) -> &[Self::Step]; + fn transcript_squeezes(&self) -> &[Self::Squeeze]; + fn transcript_absorb_bytes(&self) -> Vec; + fn opening_inputs(&self) -> &[Self::OpeningInput]; + fn field_exprs(&self) -> &[Self::FieldExpr]; + fn claims(&self) -> &[Self::Claim]; + fn batches(&self) -> &[Self::Batch]; + fn drivers(&self) -> &[Self::Driver]; + fn instance_results(&self) -> &[Self::Instance]; + fn point_zeros(&self) -> Vec; + fn point_slices(&self) -> &[Self::PointSlice]; + fn point_concats(&self) -> &[Self::PointConcat]; + fn opening_claims(&self) -> &[Self::OpeningClaim]; + fn opening_equalities(&self) -> &[Self::OpeningEquality]; + fn opening_batches(&self) -> &[Self::OpeningBatch]; +} + +pub(crate) fn stage_plan_from_cpu_sources( + source: &Source, +) -> Result +where + Source: VerifierStagePlanSource + ?Sized, +{ + Ok(VerifierStagePlan { + steps: source + .steps() + .iter() + .map(|step| VerifierProgramStepPlan::from_cpu(step.kind(), step.symbol())) + .collect::, EmitError>>()?, + transcript_squeezes: source + .transcript_squeezes() + .iter() + .map(|squeeze| { + VerifierTranscriptSqueezePlan::from_cpu( + squeeze.symbol(), + squeeze.label(), + squeeze.kind(), + squeeze.count(), + ) + }) + .collect::, EmitError>>()?, + transcript_absorb_bytes: source.transcript_absorb_bytes(), + opening_inputs: source + .opening_inputs() + .iter() + .map(|opening_input| { + VerifierOpeningInputPlan::from_cpu( + opening_input.symbol(), + opening_input.source_stage(), + opening_input.source_claim(), + opening_input.oracle(), + opening_input.domain(), + opening_input.point_arity(), + opening_input.claim_kind(), + ) + }) + .collect::, EmitError>>()?, + field_exprs: source + .field_exprs() + .iter() + .map(|expr| { + VerifierFieldExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands()) + }) + .collect::, EmitError>>()?, + claims: source + .claims() + .iter() + .map(|claim| { + Ok(VerifierSumcheckClaimPlan { + symbol: claim.symbol().to_owned(), + stage: claim.stage().to_owned(), + domain: claim.domain().to_owned(), + num_rounds: claim.num_rounds(), + degree: claim.degree(), + claim: claim.claim().to_owned(), + relation: required_relation_from_cpu( + claim.relation(), + "claim", + claim.symbol(), + )?, + claim_value: claim.claim_value().to_owned(), + }) + }) + .collect::, EmitError>>()?, + batches: source + .batches() + .iter() + .map(|batch| VerifierSumcheckBatchPlan { + symbol: batch.symbol().to_owned(), + stage: batch.stage().to_owned(), + proof_slot: batch.proof_slot().to_owned(), + policy: batch.policy().to_owned(), + count: batch.count(), + claim_operands: batch.claim_operands().to_vec(), + claim_label: batch.claim_label().to_owned(), + round_label: batch.round_label().to_owned(), + round_schedule: batch.round_schedule().to_vec(), + }) + .collect(), + drivers: source + .drivers() + .iter() + .map(|driver| { + Ok(VerifierSumcheckDriverPlan { + symbol: driver.symbol().to_owned(), + stage: driver.stage().to_owned(), + proof_slot: driver.proof_slot().to_owned(), + relation: required_relation_from_cpu( + driver.relation(), + "driver", + driver.symbol(), + )?, + batch: driver.batch().to_owned(), + policy: driver.policy().to_owned(), + round_schedule: driver.round_schedule().to_vec(), + claim_label: driver.claim_label().to_owned(), + round_label: driver.round_label().to_owned(), + num_rounds: driver.num_rounds(), + degree: driver.degree(), + }) + }) + .collect::, EmitError>>()?, + instance_results: source + .instance_results() + .iter() + .map(|instance| { + Ok(VerifierSumcheckInstanceResultPlan { + symbol: instance.symbol().to_owned(), + source: instance.source().to_owned(), + claim: instance.claim().to_owned(), + relation: relation_from_cpu(instance.relation())?, + index: instance.index(), + point_arity: instance.point_arity(), + num_rounds: instance.num_rounds(), + round_offset: instance.round_offset(), + point_order: sumcheck_point_order_from_cpu(instance.point_order())?, + degree: instance.degree(), + }) + }) + .collect::, EmitError>>()?, + point_zeros: source.point_zeros(), + point_slices: source + .point_slices() + .iter() + .map(|slice| VerifierPointSlicePlan { + symbol: slice.symbol().to_owned(), + source: slice.source().to_owned(), + offset: slice.offset(), + length: slice.length(), + input: slice.input().to_owned(), + }) + .collect(), + point_concats: source + .point_concats() + .iter() + .map(|concat| VerifierPointConcatPlan { + symbol: concat.symbol().to_owned(), + layout: concat.layout().to_owned(), + arity: concat.arity(), + inputs: concat.inputs().to_vec(), + }) + .collect(), + opening_claims: source + .opening_claims() + .iter() + .map(|claim| { + Ok(VerifierOpeningClaimPlan { + symbol: claim.symbol().to_owned(), + oracle: claim.oracle().to_owned(), + domain: claim.domain().to_owned(), + point_arity: claim.point_arity(), + claim_kind: claim_kind_from_cpu(claim.claim_kind())?, + point_source: claim.point_source().to_owned(), + eval_source: claim.eval_source().to_owned(), + }) + }) + .collect::, EmitError>>()?, + opening_equalities: source + .opening_equalities() + .iter() + .map(|equality| { + Ok(VerifierOpeningClaimEqualityPlan { + symbol: equality.symbol().to_owned(), + mode: opening_equality_mode_from_cpu(equality.mode())?, + lhs: equality.lhs().to_owned(), + rhs: equality.rhs().to_owned(), + }) + }) + .collect::, EmitError>>()?, + opening_batches: source + .opening_batches() + .iter() + .map(|batch| VerifierOpeningBatchPlan { + symbol: batch.symbol().to_owned(), + stage: batch.stage().to_owned(), + proof_slot: batch.proof_slot().to_owned(), + policy: batch.policy().to_owned(), + count: batch.count(), + ordered_claims: batch.ordered_claims().to_vec(), + claim_operands: batch.claim_operands().to_vec(), + }) + .collect(), + }) +} + +pub(crate) fn transcript_absorb_bytes_from_cpu( + absorbs: &[T], +) -> Vec { + absorbs + .iter() + .map(|absorb| { + VerifierTranscriptAbsorbBytesPlan::from_cpu( + absorb.symbol(), + absorb.label(), + absorb.payload(), + ) + }) + .collect() +} + +pub(crate) fn point_zeros_from_cpu( + zeros: &[T], +) -> Vec { + zeros + .iter() + .map(|zero| VerifierPointZeroPlan { + symbol: zero.symbol().to_owned(), + field: zero.field().to_owned(), + arity: zero.arity(), + }) + .collect() +} + +macro_rules! impl_verifier_plan_source_traits { + ( + program = $program:ty, + step = $step:ty, + squeeze = $squeeze:ty, + opening_input = $opening_input:ty, + field_expr = $field_expr:ty, + claim = $claim:ty, + batch = $batch:ty, + driver = $driver:ty, + instance = $instance:ty, + point_slice = $point_slice:ty, + point_concat = $point_concat:ty, + opening_claim = $opening_claim:ty, + opening_equality = $opening_equality:ty, + opening_batch = $opening_batch:ty + $(, absorb = $absorb:ty)? + $(, point_zero = $point_zero:ty)? + $(,)? + ) => { + impl $crate::protocols::jolt::verifier_plan::VerifierStagePlanSource for $program { + type Step = $step; + type Squeeze = $squeeze; + type OpeningInput = $opening_input; + type FieldExpr = $field_expr; + type Claim = $claim; + type Batch = $batch; + type Driver = $driver; + type Instance = $instance; + type PointSlice = $point_slice; + type PointConcat = $point_concat; + type OpeningClaim = $opening_claim; + type OpeningEquality = $opening_equality; + type OpeningBatch = $opening_batch; + + fn steps(&self) -> &[Self::Step] { &self.steps } + fn transcript_squeezes(&self) -> &[Self::Squeeze] { &self.transcript_squeezes } + fn transcript_absorb_bytes(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierTranscriptAbsorbBytesPlan> { + $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( + @transcript_absorb_bytes self $(, $absorb)? + ) + } + fn opening_inputs(&self) -> &[Self::OpeningInput] { &self.opening_inputs } + fn field_exprs(&self) -> &[Self::FieldExpr] { &self.field_exprs } + fn claims(&self) -> &[Self::Claim] { &self.claims } + fn batches(&self) -> &[Self::Batch] { &self.batches } + fn drivers(&self) -> &[Self::Driver] { &self.drivers } + fn instance_results(&self) -> &[Self::Instance] { &self.instance_results } + fn point_zeros(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierPointZeroPlan> { + $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( + @point_zeros self $(, $point_zero)? + ) + } + fn point_slices(&self) -> &[Self::PointSlice] { &self.point_slices } + fn point_concats(&self) -> &[Self::PointConcat] { &self.point_concats } + fn opening_claims(&self) -> &[Self::OpeningClaim] { &self.opening_claims } + fn opening_equalities(&self) -> &[Self::OpeningEquality] { &self.opening_equalities } + fn opening_batches(&self) -> &[Self::OpeningBatch] { &self.opening_batches } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierProgramStepSource for $step { + fn kind(&self) -> &str { &self.kind } + fn symbol(&self) -> &str { &self.symbol } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierTranscriptSqueezeSource for $squeeze { + fn symbol(&self) -> &str { &self.symbol } + fn label(&self) -> &str { &self.label } + fn kind(&self) -> &str { &self.kind } + fn count(&self) -> usize { self.count } + } + + $( + impl $crate::protocols::jolt::verifier_plan::VerifierTranscriptAbsorbBytesSource for $absorb { + fn symbol(&self) -> &str { &self.symbol } + fn label(&self) -> &str { &self.label } + fn payload(&self) -> &str { &self.payload } + } + )? + + impl $crate::protocols::jolt::verifier_plan::VerifierOpeningInputSource for $opening_input { + fn symbol(&self) -> &str { &self.symbol } + fn source_stage(&self) -> &str { &self.source_stage } + fn source_claim(&self) -> &str { &self.source_claim } + fn oracle(&self) -> &str { &self.oracle } + fn domain(&self) -> &str { &self.domain } + fn point_arity(&self) -> usize { self.point_arity } + fn claim_kind(&self) -> &str { &self.claim_kind } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierFieldExprSource for $field_expr { + fn symbol(&self) -> &str { &self.symbol } + fn formula(&self) -> &str { &self.formula } + fn operands(&self) -> &[String] { &self.operands } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckClaimSource for $claim { + fn symbol(&self) -> &str { &self.symbol } + fn stage(&self) -> &str { &self.stage } + fn domain(&self) -> &str { &self.domain } + fn num_rounds(&self) -> usize { self.num_rounds } + fn degree(&self) -> usize { self.degree } + fn claim(&self) -> &str { &self.claim } + fn relation(&self) -> Option<&str> { self.relation.as_deref() } + fn claim_value(&self) -> &str { &self.claim_value } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckBatchSource for $batch { + fn symbol(&self) -> &str { &self.symbol } + fn stage(&self) -> &str { &self.stage } + fn proof_slot(&self) -> &str { &self.proof_slot } + fn policy(&self) -> &str { &self.policy } + fn count(&self) -> usize { self.count } + fn claim_operands(&self) -> &[String] { &self.claim_operands } + fn claim_label(&self) -> &str { &self.claim_label } + fn round_label(&self) -> &str { &self.round_label } + fn round_schedule(&self) -> &[usize] { &self.round_schedule } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckDriverSource for $driver { + fn symbol(&self) -> &str { &self.symbol } + fn stage(&self) -> &str { &self.stage } + fn proof_slot(&self) -> &str { &self.proof_slot } + fn relation(&self) -> Option<&str> { self.relation.as_deref() } + fn batch(&self) -> &str { &self.batch } + fn policy(&self) -> &str { &self.policy } + fn round_schedule(&self) -> &[usize] { &self.round_schedule } + fn claim_label(&self) -> &str { &self.claim_label } + fn round_label(&self) -> &str { &self.round_label } + fn num_rounds(&self) -> usize { self.num_rounds } + fn degree(&self) -> usize { self.degree } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckInstanceResultSource for $instance { + fn symbol(&self) -> &str { &self.symbol } + fn source(&self) -> &str { &self.source } + fn claim(&self) -> &str { &self.claim } + fn relation(&self) -> &str { &self.relation } + fn index(&self) -> usize { self.index } + fn point_arity(&self) -> usize { self.point_arity } + fn num_rounds(&self) -> usize { self.num_rounds } + fn round_offset(&self) -> usize { self.round_offset } + fn point_order(&self) -> &str { &self.point_order } + fn degree(&self) -> usize { self.degree } + } + + $( + impl $crate::protocols::jolt::verifier_plan::VerifierPointZeroSource for $point_zero { + fn symbol(&self) -> &str { &self.symbol } + fn field(&self) -> &str { &self.field } + fn arity(&self) -> usize { self.arity } + } + )? + + impl $crate::protocols::jolt::verifier_plan::VerifierPointSliceSource for $point_slice { + fn symbol(&self) -> &str { &self.symbol } + fn source(&self) -> &str { &self.source } + fn offset(&self) -> usize { self.offset } + fn length(&self) -> usize { self.length } + fn input(&self) -> &str { &self.input } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierPointConcatSource for $point_concat { + fn symbol(&self) -> &str { &self.symbol } + fn layout(&self) -> &str { &self.layout } + fn arity(&self) -> usize { self.arity } + fn inputs(&self) -> &[String] { &self.inputs } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierOpeningClaimSource for $opening_claim { + fn symbol(&self) -> &str { &self.symbol } + fn oracle(&self) -> &str { &self.oracle } + fn domain(&self) -> &str { &self.domain } + fn point_arity(&self) -> usize { self.point_arity } + fn claim_kind(&self) -> &str { &self.claim_kind } + fn point_source(&self) -> &str { &self.point_source } + fn eval_source(&self) -> &str { &self.eval_source } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierOpeningClaimEqualitySource for $opening_equality { + fn symbol(&self) -> &str { &self.symbol } + fn mode(&self) -> &str { &self.mode } + fn lhs(&self) -> &str { &self.lhs } + fn rhs(&self) -> &str { &self.rhs } + } + + impl $crate::protocols::jolt::verifier_plan::VerifierOpeningBatchSource for $opening_batch { + fn symbol(&self) -> &str { &self.symbol } + fn stage(&self) -> &str { &self.stage } + fn proof_slot(&self) -> &str { &self.proof_slot } + fn policy(&self) -> &str { &self.policy } + fn count(&self) -> usize { self.count } + fn ordered_claims(&self) -> &[String] { &self.ordered_claims } + fn claim_operands(&self) -> &[String] { &self.claim_operands } + } + }; + (@transcript_absorb_bytes $self:ident, $absorb:ty) => { + $crate::protocols::jolt::verifier_plan::transcript_absorb_bytes_from_cpu( + &$self.transcript_absorb_bytes, + ) + }; + (@transcript_absorb_bytes $self:ident) => { + Vec::new() + }; + (@point_zeros $self:ident, $point_zero:ty) => { + $crate::protocols::jolt::verifier_plan::point_zeros_from_cpu(&$self.point_zeros) + }; + (@point_zeros $self:ident) => { + Vec::new() + }; +} + +pub(crate) use impl_verifier_plan_source_traits; + pub(crate) fn relation_from_cpu(value: &str) -> Result { JoltVerifierRelationKind::from_cpu_attr(value).map_err(plan_error) } From fc37ef42547e8fe282049493e6e38903aac541a6 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 10:47:20 -0600 Subject: [PATCH 084/171] refactor(bolt): share indexed eval families Add a shared Bolt-side indexed eval-family planner and use it for Stage 5 instruction read-RAF and Stage 6 bytecode read-RAF families. This removes the Stage 6-specific BytecodeRa prefix parser while preserving emitted runtime NamedEvalFamilyPlan constants. --- .../src/protocols/jolt/emit/rust/stage6.rs | 59 ++----- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../jolt/stage5_instruction_read_raf_plan.rs | 87 ++-------- .../jolt/stage6_bytecode_read_raf_plan.rs | 59 ++++--- .../protocols/jolt/verifier_eval_families.rs | 164 ++++++++++++++++++ 5 files changed, 223 insertions(+), 147 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_eval_families.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 20d7801579..5421cd17e5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -14,6 +14,7 @@ use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_output_claim_plan, }; +use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_output_claims::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, @@ -670,7 +671,7 @@ impl Stage6CpuProgram { Vec::new() }; if role == Role::Verifier { - let bytecode_ra_evals = stage6_bytecode_read_raf_eval_names(&evals)?; + let bytecode_ra_evals = stage6_bytecode_read_raf_eval_family(&evals)?; output_claims.push(stage6_bytecode_read_raf_output_claim_plan( &bytecode_ra_evals, )); @@ -1614,7 +1615,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); if self.role == Role::Verifier { - let bytecode_ra_evals = stage6_bytecode_read_raf_eval_names(&self.evals)?; + let bytecode_ra_evals = stage6_bytecode_read_raf_eval_family(&self.evals)?; source.push_str(&emit_stage6_bytecode_read_raf_plan_constants( &bytecode_ra_evals, )); @@ -2728,44 +2729,14 @@ fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi)) } -fn stage6_bytecode_read_raf_eval_names( +fn stage6_bytecode_read_raf_eval_family( evals: &[Stage6SumcheckEvalPlan], -) -> Result, EmitError> { - const PREFIX: &str = "stage6.bytecode_read_raf.eval.BytecodeRa_"; - - let mut indexed_evals = BTreeMap::new(); - for eval in evals { - let Some(suffix) = eval.name.strip_prefix(PREFIX) else { - continue; - }; - let index = suffix.parse::().map_err(|_| { - EmitError::new(format!( - "stage6 bytecode read-RAF eval `{}` has non-numeric BytecodeRa suffix", - eval.name - )) - })?; - if indexed_evals.insert(index, eval.name.clone()).is_some() { - return Err(EmitError::new(format!( - "stage6 bytecode read-RAF eval family has duplicate BytecodeRa_{index}" - ))); - } - } - if indexed_evals.is_empty() { - return Err(EmitError::new( - "stage6 bytecode read-RAF eval family is missing BytecodeRa evals", - )); - } - - let mut eval_names = Vec::with_capacity(indexed_evals.len()); - for (expected, (index, eval)) in indexed_evals.into_iter().enumerate() { - if index != expected { - return Err(EmitError::new(format!( - "stage6 bytecode read-RAF eval family is not contiguous: expected BytecodeRa_{expected}, got BytecodeRa_{index}" - ))); - } - eval_names.push(eval); - } - Ok(eval_names) +) -> Result { + IndexedEvalFamilyPlan::from_indexed_names( + "stage6.bytecode_read_raf.eval.BytecodeRa", + "stage6.bytecode_read_raf.eval.BytecodeRa_", + evals.iter().map(|eval| eval.name.as_str()), + ) } fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { @@ -2890,7 +2861,7 @@ mod tests { use crate::emit::rust::EmitError; use super::{ - stage6_bytecode_read_raf_eval_names, stage6_kernel_abi, Stage6SumcheckEvalPlan, + stage6_bytecode_read_raf_eval_family, stage6_kernel_abi, Stage6SumcheckEvalPlan, STAGE6_KERNEL_ABIS, }; @@ -2917,9 +2888,9 @@ mod tests { eval("stage6.bytecode_read_raf.eval.BytecodeRa_1"), ]; - let names = stage6_bytecode_read_raf_eval_names(&evals)?; + let family = stage6_bytecode_read_raf_eval_family(&evals)?; assert_eq!( - names, + family.evals, vec![ "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), @@ -2936,14 +2907,14 @@ mod tests { eval("stage6.bytecode_read_raf.eval.BytecodeRa_2"), ]; - let result = stage6_bytecode_read_raf_eval_names(&evals); + let result = stage6_bytecode_read_raf_eval_family(&evals); assert!(result.is_err(), "expected gap error, got {result:?}"); let error = result .err() .map(|error| error.to_string()) .unwrap_or_default(); - assert!(error.contains("not contiguous")); + assert!(error.contains("non-contiguous eval family")); } fn eval(name: &'static str) -> Stage6SumcheckEvalPlan { diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index c220309775..55ffdc075d 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -7,6 +7,7 @@ pub(crate) mod rust_target_plan; pub(crate) mod stage5_instruction_read_raf_plan; pub(crate) mod stage6_bytecode_read_raf_plan; pub mod validate; +pub(crate) mod verifier_eval_families; pub(crate) mod verifier_output_claims; pub(crate) mod verifier_plan; diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 109caf4baf..818001c700 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -1,4 +1,5 @@ use crate::emit::rust::{push_format, EmitError}; +use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_output_claims::{ StructuredPolynomialEvalPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, @@ -10,8 +11,8 @@ use crate::protocols::jolt::verifier_output_claims::{ pub(crate) struct Stage5InstructionReadRafEmitPlan { pub(crate) point: String, pub(crate) lookup_output_point: String, - pub(crate) table_flag_evals: Stage5NamedEvalFamilyEmitPlan, - pub(crate) instruction_ra_evals: Stage5NamedEvalFamilyEmitPlan, + pub(crate) table_flag_evals: IndexedEvalFamilyPlan, + pub(crate) instruction_ra_evals: IndexedEvalFamilyPlan, pub(crate) raf_flag_eval: String, pub(crate) gamma: String, pub(crate) point_values: Vec, @@ -23,12 +24,12 @@ impl Stage5InstructionReadRafEmitPlan { evals: impl IntoIterator, ) -> Result { let evals = evals.into_iter().collect::>(); - let table_flag_evals = Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( + let table_flag_evals = IndexedEvalFamilyPlan::from_indexed_oracles( "stage5.instruction_read_raf.eval.LookupTableFlag", "LookupTableFlag_", evals.iter().copied(), )?; - let instruction_ra_evals = Stage5NamedEvalFamilyEmitPlan::from_indexed_oracles( + let instruction_ra_evals = IndexedEvalFamilyPlan::from_indexed_oracles( "stage5.instruction_read_raf.eval.InstructionRa", "InstructionRa_", evals.iter().copied(), @@ -61,25 +62,12 @@ impl Stage5InstructionReadRafEmitPlan { let mut source = String::new(); for (names_const, family_const, family) in families { - let names_source = family - .evals - .iter() - .map(|name| rust_str(name)) - .collect::>() - .join(", "); - push_format( - &mut source, - format_args!( - "#[rustfmt::skip]\npub const {names_const}: &[&str] = &[{names_source}];\n" - ), - ); - push_format( - &mut source, - format_args!( - "pub const {family_const}: NamedEvalFamilyPlan = NamedEvalFamilyPlan {{ symbol: {}, evals: {names_const} }};\n\n", - rust_str(&family.symbol), - ), - ); + source.push_str(&family.emit_runtime_constant( + "pub ", + names_const, + family_const, + "NamedEvalFamilyPlan", + )); } source.push_str(&emit_point_value_constants(&self.point_values)); push_format( @@ -279,51 +267,6 @@ pub(crate) enum Stage5InstructionReadRafPointValueKind { Identity, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct Stage5NamedEvalFamilyEmitPlan { - pub(crate) symbol: String, - pub(crate) evals: Vec, -} - -impl Stage5NamedEvalFamilyEmitPlan { - fn from_indexed_oracles<'a>( - symbol: &str, - oracle_prefix: &str, - evals: impl IntoIterator, - ) -> Result { - let mut indexed_names = Vec::new(); - for (oracle, name) in evals { - let Some(suffix) = oracle.strip_prefix(oracle_prefix) else { - continue; - }; - let index = suffix.parse::().map_err(|_| { - EmitError::new(format!( - "invalid indexed eval oracle `{oracle}` for family `{symbol}`" - )) - })?; - indexed_names.push((index, name.to_owned())); - } - if indexed_names.is_empty() { - return Err(EmitError::new(format!("missing eval family `{symbol}`"))); - } - indexed_names.sort_by_key(|(index, _)| *index); - for (expected, (actual, _)) in indexed_names.iter().enumerate() { - if expected != *actual { - return Err(EmitError::new(format!( - "non-contiguous eval family `{symbol}` at index {actual}" - ))); - } - } - Ok(Self { - symbol: symbol.to_owned(), - evals: indexed_names - .into_iter() - .map(|(_, name)| name) - .collect::>(), - }) - } -} - fn point_value_plans(table_count: usize) -> Vec { let mut values = (0..table_count) .map(|index| Stage5InstructionReadRafPointValueEmitPlan { @@ -528,11 +471,9 @@ mod tests { Err(error) => error, }; - assert!( - error - .to_string() - .contains("non-contiguous eval family `stage5.instruction_read_raf.eval.LookupTableFlag` at index 1") - ); + assert!(error.to_string().contains( + "non-contiguous eval family `stage5.instruction_read_raf.eval.LookupTableFlag`" + )); Ok(()) } } diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index f3040e7f19..b20457d27c 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -1,4 +1,5 @@ use crate::emit::rust::push_format; +use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputClaimPlan, SumcheckOutputProductFamilyPlan, SumcheckOutputProductFamilyTermPlan, }; @@ -330,7 +331,9 @@ const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; -pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants(bytecode_ra_evals: &[String]) -> String { +pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants( + bytecode_ra_evals: &IndexedEvalFamilyPlan, +) -> String { emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN, bytecode_ra_evals) } @@ -340,20 +343,23 @@ pub(crate) fn stage6_bytecode_read_raf_output_contribution_symbol() -> &'static } pub(crate) fn stage6_bytecode_read_raf_output_claim_plan( - bytecode_ra_evals: &[String], + bytecode_ra_evals: &IndexedEvalFamilyPlan, ) -> SumcheckOutputClaimPlan { STAGE6_BYTECODE_READ_RAF_PLAN.output_claim_plan(bytecode_ra_evals) } impl BytecodeReadRafPlan { - fn output_claim_plan(&self, bytecode_ra_evals: &[String]) -> SumcheckOutputClaimPlan { + fn output_claim_plan( + &self, + bytecode_ra_evals: &IndexedEvalFamilyPlan, + ) -> SumcheckOutputClaimPlan { let product_family = SumcheckOutputProductFamilyPlan { symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf".to_owned(), gamma: None, terms: vec![SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: std::iter::once(self.output_contribution.to_owned()) - .chain(bytecode_ra_evals.iter().cloned()) + .chain(bytecode_ra_evals.evals.iter().cloned()) .collect(), factors: Vec::new(), }], @@ -370,30 +376,18 @@ impl BytecodeReadRafPlan { } } -fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan, bytecode_ra_evals: &[String]) -> String { +fn emit_bytecode_read_raf_plan( + plan: &BytecodeReadRafPlan, + bytecode_ra_evals: &IndexedEvalFamilyPlan, +) -> String { let mut source = "\n".to_owned(); - push_format( - &mut source, - format_args!( - "#[rustfmt::skip]\nconst {}: &[&str] = &[{}];\n", - plan.bytecode_ra_eval_names_const, - bytecode_ra_evals - .iter() - .map(|eval| rust_str(eval)) - .collect::>() - .join(", "), - ), - ); - push_format( - &mut source, - format_args!( - "const {}: bolt_verifier_runtime::NamedEvalFamilyPlan = bolt_verifier_runtime::NamedEvalFamilyPlan {{ symbol: {}, evals: {} }};\n\n", - plan.bytecode_ra_eval_family_const, - rust_str(plan.bytecode_ra_eval_family_symbol), - plan.bytecode_ra_eval_names_const, - ), - ); + source.push_str(&bytecode_ra_evals.emit_runtime_constant( + "", + plan.bytecode_ra_eval_names_const, + plan.bytecode_ra_eval_family_const, + "bolt_verifier_runtime::NamedEvalFamilyPlan", + )); for stage in plan.stages { push_format( @@ -576,16 +570,21 @@ fn rust_option_str(value: Option<&str>) -> String { #[cfg(test)] mod tests { + use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; + use super::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_output_claim_plan, stage6_bytecode_read_raf_output_contribution_symbol, BytecodeFlag, BytecodeOutputTermPlan, BytecodeReadRafTermPlan, BytecodeRegister, STAGE6_BYTECODE_READ_RAF_PLAN, }; - fn bytecode_ra_evals() -> Vec { - (0..4) - .map(|index| format!("stage6.bytecode_read_raf.eval.BytecodeRa_{index}")) - .collect() + fn bytecode_ra_evals() -> IndexedEvalFamilyPlan { + IndexedEvalFamilyPlan { + symbol: "stage6.bytecode_read_raf.eval.BytecodeRa".to_owned(), + evals: (0..4) + .map(|index| format!("stage6.bytecode_read_raf.eval.BytecodeRa_{index}")) + .collect(), + } } #[test] diff --git a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs new file mode 100644 index 0000000000..3ecb0a1258 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs @@ -0,0 +1,164 @@ +use std::collections::BTreeMap; + +use crate::emit::rust::{push_format, EmitError}; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct IndexedEvalFamilyPlan { + pub(crate) symbol: String, + pub(crate) evals: Vec, +} + +impl IndexedEvalFamilyPlan { + pub(crate) fn from_indexed_oracles<'a>( + symbol: &str, + oracle_prefix: &str, + evals: impl IntoIterator, + ) -> Result { + let evals = indexed_values( + symbol, + "eval oracle", + oracle_prefix, + evals + .into_iter() + .map(|(oracle, name)| (oracle, name.to_owned())), + )?; + Ok(Self { + symbol: symbol.to_owned(), + evals, + }) + } + + pub(crate) fn from_indexed_names<'a>( + symbol: &str, + name_prefix: &str, + eval_names: impl IntoIterator, + ) -> Result { + let evals = indexed_values( + symbol, + "eval name", + name_prefix, + eval_names + .into_iter() + .map(|eval_name| (eval_name, eval_name.to_owned())), + )?; + Ok(Self { + symbol: symbol.to_owned(), + evals, + }) + } + + pub(crate) fn emit_runtime_constant( + &self, + visibility: &str, + names_const: &str, + family_const: &str, + family_type: &str, + ) -> String { + let names_source = self + .evals + .iter() + .map(|name| rust_str(name)) + .collect::>() + .join(", "); + let mut source = String::new(); + push_format( + &mut source, + format_args!( + "#[rustfmt::skip]\n{visibility}const {names_const}: &[&str] = &[{names_source}];\n" + ), + ); + push_format( + &mut source, + format_args!( + "{visibility}const {family_const}: {family_type} = {family_type} {{ symbol: {}, evals: {names_const} }};\n\n", + rust_str(&self.symbol), + ), + ); + source + } +} + +fn indexed_values<'a>( + symbol: &str, + indexed_value_kind: &str, + prefix: &str, + values: impl IntoIterator, +) -> Result, EmitError> { + let mut indexed_values = BTreeMap::new(); + for (indexed_name, value) in values { + let Some(suffix) = indexed_name.strip_prefix(prefix) else { + continue; + }; + let index = suffix.parse::().map_err(|_| { + EmitError::new(format!( + "invalid indexed {indexed_value_kind} `{indexed_name}` for family `{symbol}`" + )) + })?; + if indexed_values.insert(index, value).is_some() { + return Err(EmitError::new(format!( + "duplicate indexed {indexed_value_kind} `{indexed_name}` for family `{symbol}`" + ))); + } + } + if indexed_values.is_empty() { + return Err(EmitError::new(format!("missing eval family `{symbol}`"))); + } + + let mut evals = Vec::with_capacity(indexed_values.len()); + for (expected, (actual, value)) in indexed_values.into_iter().enumerate() { + if expected != actual { + return Err(EmitError::new(format!( + "non-contiguous eval family `{symbol}`: expected index {expected}, got {actual}" + ))); + } + evals.push(value); + } + Ok(evals) +} + +fn rust_str(value: &str) -> String { + format!("{value:?}") +} + +#[cfg(test)] +mod tests { + use crate::emit::rust::EmitError; + + use super::IndexedEvalFamilyPlan; + + #[test] + fn named_eval_family_sorts_indexed_oracles() -> Result<(), EmitError> { + let family = IndexedEvalFamilyPlan::from_indexed_oracles( + "stage.eval.LookupTableFlag", + "LookupTableFlag_", + [ + ("LookupTableFlag_1", "stage.eval.LookupTableFlag_1"), + ("Other_0", "stage.eval.Other_0"), + ("LookupTableFlag_0", "stage.eval.LookupTableFlag_0"), + ], + )?; + + assert_eq!( + family.evals, + vec![ + "stage.eval.LookupTableFlag_0".to_owned(), + "stage.eval.LookupTableFlag_1".to_owned(), + ] + ); + Ok(()) + } + + #[test] + fn named_eval_family_rejects_gaps() { + let error = IndexedEvalFamilyPlan::from_indexed_names( + "stage.eval.BytecodeRa", + "stage.eval.BytecodeRa_", + ["stage.eval.BytecodeRa_0", "stage.eval.BytecodeRa_2"], + ) + .err() + .map(|error| error.to_string()) + .unwrap_or_default(); + + assert!(error.contains("non-contiguous eval family `stage.eval.BytecodeRa`")); + } +} From f636e7efd972dbceb25ed0955cfafb0f1c43e8d6 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 10:52:50 -0600 Subject: [PATCH 085/171] test(bolt): guard eval family prefix cutover Update the verifier refactor plan to reflect the current S4 state and add verifier cleanup coverage for indexed eval-prefix reconstruction. The generated verifier metrics now enforce zero relation indexed-eval prefix sites, and the runtime has a direct regression test against reintroducing prefix APIs. --- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 48 ++++++++++--------- crates/bolt/tests/verifier_cleanup.rs | 37 +++++++++++++- 2 files changed, 62 insertions(+), 23 deletions(-) diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index e15fecf73c..54eedbffd8 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -739,24 +739,25 @@ updates. ## S4: Typed indexed-eval addressing -**Goal.** Eliminate the last big string-dispatch site in Tier B: -`indexed_evals_by_prefix_any(evals, "stage6.booleanity.eval.InstructionRa_")` -and friends. Replace with a typed eval-family vocabulary. +**Goal.** Keep eval-family reconstruction out of verifier runtime/Tier B and +finish moving indexed-eval family facts into typed verifier-plan data. -### The problem today +### Current status -Stage 6/7 evaluators do: +The original Tier B problem has been removed on the current stack. Generated +Jolt relation code and `bolt-verifier-runtime` no longer call +`indexed_evals_by_prefix*`, and `verifier_cleanup` now gates both generated +relation code and the runtime against reintroducing indexed eval-prefix APIs. -```rust -let booleanity_evals = - indexed_evals_by_prefix_any(evals, "stage6.booleanity.eval.InstructionRa_")?; -``` +Stage 5 instruction read-RAF and Stage 6 bytecode read-RAF share a Bolt-side +`IndexedEvalFamilyPlan` helper for contiguous indexed families. This is a +planning seam, not the final architecture: the helper still derives family +membership from emitted eval names or oracle names during Rust planning. -This works because the prover emits evals named `..._0, ..._1, ..._2` and -the verifier wants them as `Vec`. The verifier reconstructs the family -by string-prefix matching plus integer-suffix parsing. This is the *only* -remaining "execution-relevant string dispatch" that the current -`verifier_cleanup` gates do not yet enforce-to-zero. +The remaining S4 work is therefore not "delete the runtime helper"; it is +"promote eval-family membership to CPU/verifier-plan rows so Rust emission +formats typed family data instead of discovering indexed families from symbol +spelling." ### Dialect changes @@ -797,9 +798,10 @@ not a set of scalars recovered by prefix matching. ### Tier B impact -Each `expected_stage67_*` that today calls `indexed_evals_by_prefix_any` -instead reads a typed `&[Fr]` from the store. Estimated ~60 LOC reduction -in Tier B. +Stage 6/7 relation evaluators should continue to receive typed eval-family +plans or typed field-vector values, never reconstruct families from prefixes. +Remaining reductions are expected on the Bolt emitter/planning side, not from +deleting more Tier B prefix code. ### Blockers and complications @@ -811,17 +813,19 @@ in Tier B. - **Prover/verifier symmetry.** The prover-side emitter must annotate the same eval block as a family. If this is a separate emitter, both must be updated together. -- **`indexed_evals_by_prefix` and `indexed_evals_by_prefix_any` removal.** - These two helpers in Tier A become unused after S4. They can be deleted - from `bolt-verifier-runtime` to keep the API surface minimal. +- **Typed source of truth.** `IndexedEvalFamilyPlan` is still an emitter helper. + The next step is a CPU/verifier-plan row for named eval families so the Rust + emitter consumes explicit family data. - **Testing.** Add a `verifier_cleanup` gate `RELATION_INDEXED_EVAL_PREFIX_SITES_CEILING = 0` that fires if any - generated stage source still calls `indexed_evals_by_prefix*`. + generated stage source still calls `indexed_evals_by_prefix*` or exposes + eval-prefix fields. This gate is now present. ### Acceptance criteria `muldiv` passes in both modes. Zero `indexed_evals_by_prefix*` call sites -in the generated verifier. Tier B drops to ~350 LOC. +in the generated verifier and runtime. Indexed eval-family membership is +represented as typed CPU/verifier-plan data before Rust token emission. ### Rollback diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 3d4617f0de..01f4202ee8 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -37,6 +37,7 @@ const STAGE_LOCAL_MACRO_RULES_BASELINE_CEILING: usize = 0; const STAGE_HELPER_FUNCTION_BASELINE_CEILING: usize = 38; const RELATION_STRING_SITE_BASELINE_CEILING: usize = 0; const SUMCHECK_POINT_ORDER_STRING_SITE_BASELINE_CEILING: usize = 0; +const RELATION_INDEXED_EVAL_PREFIX_SITE_BASELINE_CEILING: usize = 0; const ALLOWED_JOLT_PROTOCOL_SYMBOLS: &[&str] = &[ "jolt.commitment_phase", @@ -143,6 +144,7 @@ struct VerifierCleanupMetrics { stage_local_helper_functions: usize, relation_string_sites: usize, sumcheck_point_order_string_sites: usize, + relation_indexed_eval_prefix_sites: usize, } #[test] @@ -169,7 +171,8 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { stage_local_macro_rules: {stage_local_macro_rules} (baseline ceiling <= {macro_rules_baseline})\n\ stage_local_helper_functions: {helper_functions} (baseline ceiling <= {helper_baseline})\n\ relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})\n\ - sumcheck_point_order_string_sites: {point_order_sites} (baseline ceiling <= {point_order_baseline})", + sumcheck_point_order_string_sites: {point_order_sites} (baseline ceiling <= {point_order_baseline})\n\ + relation_indexed_eval_prefix_sites: {indexed_eval_prefix_sites} (baseline ceiling <= {indexed_eval_prefix_baseline})", generated_surface_loc = metrics.generated_surface_loc, bolt_runtime_loc = metrics.bolt_runtime_loc, bolt_runtime_baseline = BOLT_RUNTIME_BASELINE_LOC_CEILING, @@ -204,6 +207,8 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { relation_baseline = RELATION_STRING_SITE_BASELINE_CEILING, point_order_sites = metrics.sumcheck_point_order_string_sites, point_order_baseline = SUMCHECK_POINT_ORDER_STRING_SITE_BASELINE_CEILING, + indexed_eval_prefix_sites = metrics.relation_indexed_eval_prefix_sites, + indexed_eval_prefix_baseline = RELATION_INDEXED_EVAL_PREFIX_SITE_BASELINE_CEILING, ); assert!( @@ -293,6 +298,12 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { "sumcheck point-order string sites grew to {}; prefer typed point-order plan data", metrics.sumcheck_point_order_string_sites ); + assert!( + metrics.relation_indexed_eval_prefix_sites + == RELATION_INDEXED_EVAL_PREFIX_SITE_BASELINE_CEILING, + "relation indexed-eval prefix sites grew to {}; prefer typed eval-family plan data", + metrics.relation_indexed_eval_prefix_sites + ); } #[test] @@ -457,6 +468,21 @@ fn stage67_output_plan_cutover_removed_obsolete_relation_helpers() { } } +#[test] +fn verifier_runtime_has_no_indexed_eval_prefix_api() { + let runtime = workspace_root().join("crates/bolt-verifier-runtime/src/lib.rs"); + if !runtime.exists() { + return; + } + let source = std::fs::read_to_string(&runtime).expect("read verifier runtime source"); + for stale in ["indexed_evals_by_prefix", "eval_prefix"] { + assert!( + !source.contains(stale), + "bolt-verifier-runtime still exposes indexed eval-prefix API `{stale}`" + ); + } +} + #[test] fn verifier_cpu_fixtures_are_kernel_free() { let fixtures = workspace_root().join("crates/bolt/tests/fixtures"); @@ -632,6 +658,8 @@ fn verifier_cleanup_metrics(verifier_src: &Path) -> VerifierCleanupMetrics { metrics.relation_string_sites += count_relation_string_sites(&source); metrics.sumcheck_point_order_string_sites += count_sumcheck_point_order_string_sites(&source); + metrics.relation_indexed_eval_prefix_sites += + count_relation_indexed_eval_prefix_sites(&source); } } metrics @@ -743,6 +771,13 @@ fn count_sumcheck_point_order_string_sites(source: &str) -> usize { .count() } +fn count_relation_indexed_eval_prefix_sites(source: &str) -> usize { + source + .lines() + .filter(|line| line.contains("indexed_evals_by_prefix") || line.contains("eval_prefix")) + .count() +} + fn assert_allowed_jolt_protocol_symbol(path: &Path, symbol: &str) { assert!( ALLOWED_JOLT_PROTOCOL_SYMBOLS.contains(&symbol), From 3e48c9c5e7cc9e9f6b40d05f4db43cddf4ffc333 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 12:14:47 -0600 Subject: [PATCH 086/171] refactor(bolt): plan indexed eval families Carry Stage 5/6 indexed eval-family membership as verifier-stage plan data before Rust emission. Stage 5 instruction read-RAF and Stage 6 bytecode read-RAF now consume explicit IndexedEvalFamilyPlan rows rather than building relation plans directly from raw eval lists. Verification: cargo fmt -q; cargo check -p bolt --quiet; cargo clippy -p bolt --all-targets -q -- -D warnings; cargo nextest run -p bolt --cargo-quiet; cargo check -p jolt-verifier -p jolt-equivalence --quiet; cargo nextest run -p jolt-equivalence --cargo-quiet; git diff --check. --- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 24 +++--- .../src/protocols/jolt/emit/rust/stage5.rs | 51 +++++++++---- .../src/protocols/jolt/emit/rust/stage6.rs | 61 ++++++++++++---- .../jolt/stage5_instruction_read_raf_plan.rs | 73 ++++++++++++++----- .../jolt/stage6_bytecode_read_raf_plan.rs | 4 +- .../protocols/jolt/verifier_eval_families.rs | 14 ++++ .../bolt/src/protocols/jolt/verifier_plan.rs | 16 ++++ 7 files changed, 186 insertions(+), 57 deletions(-) diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 54eedbffd8..2a85a03160 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -749,15 +749,16 @@ Jolt relation code and `bolt-verifier-runtime` no longer call `indexed_evals_by_prefix*`, and `verifier_cleanup` now gates both generated relation code and the runtime against reintroducing indexed eval-prefix APIs. -Stage 5 instruction read-RAF and Stage 6 bytecode read-RAF share a Bolt-side -`IndexedEvalFamilyPlan` helper for contiguous indexed families. This is a -planning seam, not the final architecture: the helper still derives family -membership from emitted eval names or oracle names during Rust planning. +Stage 5 instruction read-RAF and Stage 6 bytecode read-RAF now carry explicit +Bolt-side `IndexedEvalFamilyPlan` rows in the verifier-stage plan. The relevant +relation/output-claim planners consume those rows instead of re-deriving the +family from raw evals at the point of Rust token emission. -The remaining S4 work is therefore not "delete the runtime helper"; it is -"promote eval-family membership to CPU/verifier-plan rows so Rust emission -formats typed family data instead of discovering indexed families from symbol -spelling." +This is still not the final architecture. The temporary CPU-to-verifier row +builders derive Stage 5/6 family membership from existing eval names/oracle +names because the CPU IR does not yet have a first-class eval-family op. The +remaining S4 work is therefore to move the source of those family rows into +typed CPU/MLIR data instead of constructing them at the Rust planning boundary. ### Dialect changes @@ -813,9 +814,10 @@ deleting more Tier B prefix code. - **Prover/verifier symmetry.** The prover-side emitter must annotate the same eval block as a family. If this is a separate emitter, both must be updated together. -- **Typed source of truth.** `IndexedEvalFamilyPlan` is still an emitter helper. - The next step is a CPU/verifier-plan row for named eval families so the Rust - emitter consumes explicit family data. +- **Typed source of truth.** `IndexedEvalFamilyPlan` is now a verifier-plan row + consumed by Stage 5/6 relation planning. The next step is replacing the + temporary boundary derivation with CPU/MLIR eval-family rows, so the + verifier plan does not infer family membership from symbol spelling at all. - **Testing.** Add a `verifier_cleanup` gate `RELATION_INDEXED_EVAL_PREFIX_SITES_CEILING = 0` that fires if any generated stage source still calls `indexed_evals_by_prefix*` or exposes diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 62c02e6416..fa8a5682cc 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -13,7 +13,9 @@ use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, + STAGE5_INSTRUCTION_RA_EVAL_FAMILY, STAGE5_TABLE_FLAG_EVAL_FAMILY, }; +use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_output_claims::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, @@ -31,8 +33,8 @@ use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5CpuProgram { pub role: Role, - pub(crate) instruction_read_raf_plan: Option, pub(crate) verifier_plan: Option, + pub(crate) indexed_eval_families: Vec, pub params: Stage5Params, pub steps: Vec, pub transcript_squeezes: Vec, @@ -272,6 +274,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_equality = Stage5OpeningClaimEqualityPlan, opening_batch = Stage5OpeningBatchPlan, absorb = Stage5TranscriptAbsorbBytesPlan, + indexed_eval_families = indexed_eval_families, ); pub fn stage5_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -623,14 +626,10 @@ impl Stage5CpuProgram { .map(|claim| claim.claim_value.as_str()), ); } - let instruction_read_raf_plan = if role == Role::Verifier { - Some(Stage5InstructionReadRafEmitPlan::from_evals( - evals - .iter() - .map(|eval| (eval.oracle.as_str(), eval.name.as_str())), - )?) + let indexed_eval_families = if role == Role::Verifier { + stage5_instruction_read_raf_eval_families(&evals)? } else { - None + Vec::new() }; let mut output_claims = if role == Role::Verifier { verifier_output_claims::resolve_output_claims( @@ -645,8 +644,10 @@ impl Stage5CpuProgram { } else { Vec::new() }; - if let Some(plan) = &instruction_read_raf_plan { - let output_plan = plan.output_claim_plan(); + if role == Role::Verifier { + let output_plan = + Stage5InstructionReadRafEmitPlan::from_eval_families(&indexed_eval_families)? + .output_claim_plan(); field_exprs.extend(output_plan.field_exprs.into_iter().map(stage5_field_expr)); output_claims.push(output_plan.claim); } @@ -654,8 +655,8 @@ impl Stage5CpuProgram { let mut program = Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, role, - instruction_read_raf_plan, verifier_plan: None, + indexed_eval_families, steps, transcript_squeezes, transcript_absorb_bytes, @@ -2015,10 +2016,9 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_named_eval_family_constants(&self) -> Result { - let plan = self - .instruction_read_raf_plan - .as_ref() - .ok_or_else(|| EmitError::new("missing stage5 instruction read-RAF plan"))?; + let plan = Stage5InstructionReadRafEmitPlan::from_eval_families( + &self.verifier_plan()?.indexed_eval_families, + )?; Ok(plan.emit_runtime_constants()) } @@ -2545,6 +2545,27 @@ fn expected_batched_output_claim( } } +fn stage5_instruction_read_raf_eval_families( + evals: &[Stage5SumcheckEvalPlan], +) -> Result, EmitError> { + Ok(vec![ + IndexedEvalFamilyPlan::from_indexed_oracles( + STAGE5_TABLE_FLAG_EVAL_FAMILY, + "LookupTableFlag_", + evals + .iter() + .map(|eval| (eval.oracle.as_str(), eval.name.as_str())), + )?, + IndexedEvalFamilyPlan::from_indexed_oracles( + STAGE5_INSTRUCTION_RA_EVAL_FAMILY, + "InstructionRa_", + evals + .iter() + .map(|eval| (eval.oracle.as_str(), eval.name.as_str())), + )?, + ]) +} + fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result<(), EmitError> { if actual == expected { Ok(()) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 5421cd17e5..f162e8c097 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -13,6 +13,7 @@ use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_output_claim_plan, + STAGE6_BYTECODE_RA_EVAL_FAMILY, }; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_output_claims::{ @@ -60,6 +61,7 @@ const STAGE6_KERNEL_ABIS: &[(&str, &str)] = &[ pub struct Stage6CpuProgram { pub role: Role, pub(crate) verifier_plan: Option, + pub(crate) indexed_eval_families: Vec, pub params: Stage6Params, pub steps: Vec, pub transcript_squeezes: Vec, @@ -298,6 +300,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_batch = Stage6OpeningBatchPlan, absorb = Stage6TranscriptAbsorbBytesPlan, point_zero = Stage6PointZeroPlan, + indexed_eval_families = indexed_eval_families, ); pub fn stage6_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -657,6 +660,11 @@ impl Stage6CpuProgram { .map(|claim| claim.claim_value.as_str()), ); } + let indexed_eval_families = if role == Role::Verifier { + stage6_indexed_eval_families(&evals)? + } else { + Vec::new() + }; let mut output_claims = if role == Role::Verifier { verifier_output_claims::resolve_output_claims( "stage6", @@ -671,9 +679,9 @@ impl Stage6CpuProgram { Vec::new() }; if role == Role::Verifier { - let bytecode_ra_evals = stage6_bytecode_read_raf_eval_family(&evals)?; + let bytecode_ra_evals = stage6_bytecode_read_raf_eval_family(&indexed_eval_families)?; output_claims.push(stage6_bytecode_read_raf_output_claim_plan( - &bytecode_ra_evals, + bytecode_ra_evals, )); } @@ -681,6 +689,7 @@ impl Stage6CpuProgram { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, role, verifier_plan: None, + indexed_eval_families, steps, transcript_squeezes, transcript_absorb_bytes, @@ -1615,9 +1624,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); if self.role == Role::Verifier { - let bytecode_ra_evals = stage6_bytecode_read_raf_eval_family(&self.evals)?; + let bytecode_ra_evals = + stage6_bytecode_read_raf_eval_family(&self.verifier_plan()?.indexed_eval_families)?; source.push_str(&emit_stage6_bytecode_read_raf_plan_constants( - &bytecode_ra_evals, + bytecode_ra_evals, )); source.push_str(&self.emit_verifier_output_claim_constants()?); } @@ -2729,14 +2739,20 @@ fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi)) } -fn stage6_bytecode_read_raf_eval_family( +fn stage6_indexed_eval_families( evals: &[Stage6SumcheckEvalPlan], -) -> Result { - IndexedEvalFamilyPlan::from_indexed_names( - "stage6.bytecode_read_raf.eval.BytecodeRa", +) -> Result, EmitError> { + Ok(vec![IndexedEvalFamilyPlan::from_indexed_names( + STAGE6_BYTECODE_RA_EVAL_FAMILY, "stage6.bytecode_read_raf.eval.BytecodeRa_", evals.iter().map(|eval| eval.name.as_str()), - ) + )?]) +} + +fn stage6_bytecode_read_raf_eval_family( + eval_families: &[IndexedEvalFamilyPlan], +) -> Result<&IndexedEvalFamilyPlan, EmitError> { + IndexedEvalFamilyPlan::find(eval_families, STAGE6_BYTECODE_RA_EVAL_FAMILY) } fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { @@ -2859,10 +2875,11 @@ fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { #[cfg(test)] mod tests { use crate::emit::rust::EmitError; + use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use super::{ - stage6_bytecode_read_raf_eval_family, stage6_kernel_abi, Stage6SumcheckEvalPlan, - STAGE6_KERNEL_ABIS, + stage6_bytecode_read_raf_eval_family, stage6_indexed_eval_families, stage6_kernel_abi, + Stage6SumcheckEvalPlan, STAGE6_BYTECODE_RA_EVAL_FAMILY, STAGE6_KERNEL_ABIS, }; #[test] @@ -2888,7 +2905,8 @@ mod tests { eval("stage6.bytecode_read_raf.eval.BytecodeRa_1"), ]; - let family = stage6_bytecode_read_raf_eval_family(&evals)?; + let families = stage6_indexed_eval_families(&evals)?; + let family = stage6_bytecode_read_raf_eval_family(&families)?; assert_eq!( family.evals, vec![ @@ -2907,7 +2925,7 @@ mod tests { eval("stage6.bytecode_read_raf.eval.BytecodeRa_2"), ]; - let result = stage6_bytecode_read_raf_eval_family(&evals); + let result = stage6_indexed_eval_families(&evals); assert!(result.is_err(), "expected gap error, got {result:?}"); let error = result .err() @@ -2917,6 +2935,23 @@ mod tests { assert!(error.contains("non-contiguous eval family")); } + #[test] + fn stage6_bytecode_read_raf_eval_family_requires_explicit_plan_row() { + let families = [IndexedEvalFamilyPlan { + symbol: "stage6.other.eval.BytecodeRa".to_owned(), + evals: vec!["stage6.other.eval.BytecodeRa_0".to_owned()], + }]; + + let error = stage6_bytecode_read_raf_eval_family(&families) + .err() + .map(|error| error.to_string()) + .unwrap_or_default(); + + assert!(error.contains(&format!( + "missing eval family `{STAGE6_BYTECODE_RA_EVAL_FAMILY}`" + ))); + } + fn eval(name: &'static str) -> Stage6SumcheckEvalPlan { Stage6SumcheckEvalPlan { symbol: name.to_owned(), diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 818001c700..d207b3c2e3 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -7,6 +7,11 @@ use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputProductFamilyTermPlan, }; +pub(crate) const STAGE5_TABLE_FLAG_EVAL_FAMILY: &str = + "stage5.instruction_read_raf.eval.LookupTableFlag"; +pub(crate) const STAGE5_INSTRUCTION_RA_EVAL_FAMILY: &str = + "stage5.instruction_read_raf.eval.InstructionRa"; + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Stage5InstructionReadRafEmitPlan { pub(crate) point: String, @@ -20,20 +25,13 @@ pub(crate) struct Stage5InstructionReadRafEmitPlan { } impl Stage5InstructionReadRafEmitPlan { - pub(crate) fn from_evals<'a>( - evals: impl IntoIterator, + pub(crate) fn from_eval_families( + eval_families: &[IndexedEvalFamilyPlan], ) -> Result { - let evals = evals.into_iter().collect::>(); - let table_flag_evals = IndexedEvalFamilyPlan::from_indexed_oracles( - "stage5.instruction_read_raf.eval.LookupTableFlag", - "LookupTableFlag_", - evals.iter().copied(), - )?; - let instruction_ra_evals = IndexedEvalFamilyPlan::from_indexed_oracles( - "stage5.instruction_read_raf.eval.InstructionRa", - "InstructionRa_", - evals.iter().copied(), - )?; + let table_flag_evals = + IndexedEvalFamilyPlan::find(eval_families, STAGE5_TABLE_FLAG_EVAL_FAMILY)?.clone(); + let instruction_ra_evals = + IndexedEvalFamilyPlan::find(eval_families, STAGE5_INSTRUCTION_RA_EVAL_FAMILY)?.clone(); Ok(Self { point: "stage5.instruction_read_raf.point".to_owned(), lookup_output_point: "stage5.input.stage2.instruction.LookupOutput".to_owned(), @@ -344,12 +342,16 @@ fn rust_str(value: &str) -> String { #[cfg(test)] mod tests { use crate::emit::rust::EmitError; + use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; - use super::Stage5InstructionReadRafEmitPlan; + use super::{ + Stage5InstructionReadRafEmitPlan, STAGE5_INSTRUCTION_RA_EVAL_FAMILY, + STAGE5_TABLE_FLAG_EVAL_FAMILY, + }; #[test] fn instruction_read_raf_plan_groups_indexed_eval_families() -> Result<(), EmitError> { - let plan = Stage5InstructionReadRafEmitPlan::from_evals([ + let families = instruction_read_raf_families([ ( "LookupTableFlag_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1", @@ -367,6 +369,7 @@ mod tests { "stage5.instruction_read_raf.eval.LookupTableFlag_0", ), ])?; + let plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&families)?; assert_eq!( plan.table_flag_evals.evals, @@ -384,7 +387,7 @@ mod tests { #[test] fn instruction_read_raf_output_claim_plan_is_typed() -> Result<(), EmitError> { - let plan = Stage5InstructionReadRafEmitPlan::from_evals([ + let families = instruction_read_raf_families([ ( "LookupTableFlag_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0", @@ -398,6 +401,7 @@ mod tests { "stage5.instruction_read_raf.eval.InstructionRa_0", ), ])?; + let plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&families)?; let output_plan = plan.output_claim_plan(); assert_eq!( @@ -453,7 +457,7 @@ mod tests { #[test] fn instruction_read_raf_plan_rejects_non_contiguous_eval_families() -> Result<(), EmitError> { - let error = match Stage5InstructionReadRafEmitPlan::from_evals([ + let error = match instruction_read_raf_families([ ( "LookupTableFlag_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1", @@ -476,4 +480,39 @@ mod tests { )); Ok(()) } + + #[test] + fn instruction_read_raf_plan_requires_explicit_eval_family_rows() { + let families = [IndexedEvalFamilyPlan { + symbol: STAGE5_TABLE_FLAG_EVAL_FAMILY.to_owned(), + evals: vec!["stage5.instruction_read_raf.eval.LookupTableFlag_0".to_owned()], + }]; + + let error = Stage5InstructionReadRafEmitPlan::from_eval_families(&families) + .err() + .map(|error| error.to_string()) + .unwrap_or_default(); + + assert!( + error.contains("missing eval family `stage5.instruction_read_raf.eval.InstructionRa`") + ); + } + + fn instruction_read_raf_families<'a>( + evals: impl IntoIterator, + ) -> Result, EmitError> { + let evals = evals.into_iter().collect::>(); + Ok(vec![ + IndexedEvalFamilyPlan::from_indexed_oracles( + STAGE5_TABLE_FLAG_EVAL_FAMILY, + "LookupTableFlag_", + evals.iter().copied(), + )?, + IndexedEvalFamilyPlan::from_indexed_oracles( + STAGE5_INSTRUCTION_RA_EVAL_FAMILY, + "InstructionRa_", + evals.iter().copied(), + )?, + ]) + } } diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index b20457d27c..5ed30290ee 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -4,6 +4,8 @@ use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputClaimPlan, SumcheckOutputProductFamilyPlan, SumcheckOutputProductFamilyTermPlan, }; +pub(crate) const STAGE6_BYTECODE_RA_EVAL_FAMILY: &str = "stage6.bytecode_read_raf.eval.BytecodeRa"; + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) struct BytecodeReadRafPlan { pub(crate) const_name: &'static str, @@ -315,7 +317,7 @@ const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { gamma: "stage6.bytecode_read_raf.gamma", bytecode_ra_eval_names_const: "STAGE6_BYTECODE_RA_EVAL_NAMES", bytecode_ra_eval_family_const: "STAGE6_BYTECODE_RA_EVALS", - bytecode_ra_eval_family_symbol: "stage6.bytecode_read_raf.eval.BytecodeRa", + bytecode_ra_eval_family_symbol: STAGE6_BYTECODE_RA_EVAL_FAMILY, entries: "stage6.bytecode_read_raf.entries", entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", stages_const: "STAGE6_BYTECODE_STAGES", diff --git a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs index 3ecb0a1258..e46f9673eb 100644 --- a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs +++ b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs @@ -9,6 +9,20 @@ pub(crate) struct IndexedEvalFamilyPlan { } impl IndexedEvalFamilyPlan { + pub(crate) fn find<'a>( + families: &'a [Self], + symbol: &str, + ) -> Result<&'a IndexedEvalFamilyPlan, EmitError> { + let mut matching_families = families.iter().filter(|family| family.symbol == symbol); + let family = matching_families + .next() + .ok_or_else(|| EmitError::new(format!("missing eval family `{symbol}`")))?; + if matching_families.next().is_some() { + return Err(EmitError::new(format!("duplicate eval family `{symbol}`"))); + } + Ok(family) + } + pub(crate) fn from_indexed_oracles<'a>( symbol: &str, oracle_prefix: &str, diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 31c3691d47..bbc46da458 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -5,6 +5,7 @@ use crate::protocols::jolt::rust_target_plan::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, ProgramStepKind, RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, }; +use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierProgramStepPlan { @@ -235,6 +236,7 @@ pub(crate) struct VerifierStagePlan { pub(crate) batches: Vec, pub(crate) drivers: Vec, pub(crate) instance_results: Vec, + pub(crate) indexed_eval_families: Vec, pub(crate) point_zeros: Vec, pub(crate) point_slices: Vec, pub(crate) point_concats: Vec, @@ -399,6 +401,7 @@ pub(crate) trait VerifierStagePlanSource { fn batches(&self) -> &[Self::Batch]; fn drivers(&self) -> &[Self::Driver]; fn instance_results(&self) -> &[Self::Instance]; + fn indexed_eval_families(&self) -> &[IndexedEvalFamilyPlan]; fn point_zeros(&self) -> Vec; fn point_slices(&self) -> &[Self::PointSlice]; fn point_concats(&self) -> &[Self::PointConcat]; @@ -530,6 +533,7 @@ where }) }) .collect::, EmitError>>()?, + indexed_eval_families: source.indexed_eval_families().to_vec(), point_zeros: source.point_zeros(), point_slices: source .point_slices() @@ -641,6 +645,7 @@ macro_rules! impl_verifier_plan_source_traits { opening_batch = $opening_batch:ty $(, absorb = $absorb:ty)? $(, point_zero = $point_zero:ty)? + $(, indexed_eval_families = $indexed_eval_families:ident)? $(,)? ) => { impl $crate::protocols::jolt::verifier_plan::VerifierStagePlanSource for $program { @@ -671,6 +676,11 @@ macro_rules! impl_verifier_plan_source_traits { fn batches(&self) -> &[Self::Batch] { &self.batches } fn drivers(&self) -> &[Self::Driver] { &self.drivers } fn instance_results(&self) -> &[Self::Instance] { &self.instance_results } + fn indexed_eval_families(&self) -> &[$crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan] { + $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( + @indexed_eval_families self $(, $indexed_eval_families)? + ) + } fn point_zeros(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierPointZeroPlan> { $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( @point_zeros self $(, $point_zero)? @@ -833,6 +843,12 @@ macro_rules! impl_verifier_plan_source_traits { (@point_zeros $self:ident) => { Vec::new() }; + (@indexed_eval_families $self:ident, $indexed_eval_families:ident) => { + &$self.$indexed_eval_families + }; + (@indexed_eval_families $self:ident) => { + &[] + }; } pub(crate) use impl_verifier_plan_source_traits; From d0233f5e15334d8dcb0193a4df8c729b7447ceed Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 13:25:37 -0600 Subject: [PATCH 087/171] refactor(bolt): add eval-family IR rows Thread explicit sumcheck eval-family rows through PIOP, compute, and CPU lowering so Stage 5/6 verifier planning consumes MLIR-derived family membership instead of reconstructing it from eval-name prefixes. Tighten schema validation for family count/eval consistency and document the current S4 metadata-row state. --- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 67 +++++---- crates/bolt/irdl/compute.mlir | 14 ++ crates/bolt/irdl/cpu.mlir | 14 ++ crates/bolt/irdl/piop.mlir | 14 ++ .../src/protocols/jolt/emit/rust/stage5.rs | 41 +++--- .../src/protocols/jolt/emit/rust/stage6.rs | 80 ++++------- .../src/protocols/jolt/phases/commitment.rs | 10 ++ .../src/protocols/jolt/phases/lowering.rs | 10 ++ .../bolt/src/protocols/jolt/phases/stage1.rs | 10 ++ .../bolt/src/protocols/jolt/phases/stage5.rs | 43 ++++++ .../bolt/src/protocols/jolt/phases/stage6.rs | 33 +++++ .../jolt/stage5_instruction_read_raf_plan.rs | 68 ++++----- .../protocols/jolt/verifier_eval_families.rs | 131 +++--------------- crates/bolt/src/schema.rs | 46 ++++++ crates/bolt/tests/commitment_ir.rs | 39 ++++++ 15 files changed, 360 insertions(+), 260 deletions(-) diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 2a85a03160..cfec88c8af 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -754,48 +754,47 @@ Bolt-side `IndexedEvalFamilyPlan` rows in the verifier-stage plan. The relevant relation/output-claim planners consume those rows instead of re-deriving the family from raw evals at the point of Rust token emission. -This is still not the final architecture. The temporary CPU-to-verifier row -builders derive Stage 5/6 family membership from existing eval names/oracle -names because the CPU IR does not yet have a first-class eval-family op. The -remaining S4 work is therefore to move the source of those family rows into -typed CPU/MLIR data instead of constructing them at the Rust planning boundary. +Stage 5/6 family membership now originates as first-class +`piop.sumcheck_eval_family`, `compute.sumcheck_eval_family`, and +`cpu.sumcheck_eval_family` rows. The CPU-to-verifier planning layer parses those +rows directly; it no longer infers family membership from symbol spelling, +oracle prefixes, or raw eval ordering. + +This is still not the final architecture. The current family op is typed +planning metadata with explicit `evals` membership, not yet a first-class +field-vector value in the verifier value graph. S3 should decide how field +vectors/eval families flow as typed values; S4's job is to make the existing +Stage 5/6 family facts explicit and non-prefix-derived before Rust token +emission. ### Dialect changes -Extend `compute::sumcheck_eval` with an `eval_family` attribute (or add a -sibling `compute::sumcheck_eval_family` op): +Add a sibling no-result eval-family op in the PIOP, compute, and CPU dialects: ```mlir compute.sumcheck_eval_family { - sym_name = "stage6.booleanity.instruction_ra_family" - produced_by = @stage6_booleanity_driver - oracle_family = "InstructionRa" + sym_name = "stage6.bytecode_read_raf.eval.BytecodeRa" + source = "stage6.sumcheck" + oracle_family = "BytecodeRa" count = 3 -} -> %eval_vec : !field_vector + evals = [@stage6.bytecode_read_raf.eval.BytecodeRa_0, + @stage6.bytecode_read_raf.eval.BytecodeRa_1, + @stage6.bytecode_read_raf.eval.BytecodeRa_2] +} ``` -The existing `compute::sumcheck_eval` ops with names like -`...InstructionRa_0`, `...InstructionRa_1`, ... are replaced by a single -family op when the consumer needs the block as a vector. The prover side -already emits these as a contiguous block; the verifier side gains a typed -`!field_vector` handle to the whole block. +The existing scalar `sumcheck_eval` ops remain the source of the serialized +named evals. The family row is an explicit membership declaration consumed by +the verifier-plan layer. A later S3/S5 value-graph slice can promote this shape +to a typed field-vector value if that makes the Rust emission smaller and +clearer. ### Runtime additions -Add `EvalFamilyPlan` to `bolt-verifier-runtime`: - -```rust -pub struct EvalFamilyPlan { - pub symbol: &'static str, - pub source: &'static str, // sumcheck driver symbol - pub oracle_family: &'static str, // diagnostic - pub count: usize, -} -``` - -`ValueStore` learns to materialize a `FieldVector` value for family symbols -when the parent sumcheck output is observed. Consumers ask for a typed vector, -not a set of scalars recovered by prefix matching. +No runtime API is added for the metadata-row phase. `bolt-verifier-runtime` +continues to expose only the boring reusable mechanics, while the Jolt verifier +plan carries `IndexedEvalFamilyPlan` rows. Runtime `FieldVector`/`ValueStore` +support belongs in S3 only if the typed verifier value graph needs it. ### Tier B impact @@ -814,10 +813,10 @@ deleting more Tier B prefix code. - **Prover/verifier symmetry.** The prover-side emitter must annotate the same eval block as a family. If this is a separate emitter, both must be updated together. -- **Typed source of truth.** `IndexedEvalFamilyPlan` is now a verifier-plan row - consumed by Stage 5/6 relation planning. The next step is replacing the - temporary boundary derivation with CPU/MLIR eval-family rows, so the - verifier plan does not infer family membership from symbol spelling at all. +- **Typed source of truth.** `IndexedEvalFamilyPlan` is now parsed from + CPU/MLIR eval-family rows for Stage 5/6. Remaining risk is scope, not + ambiguity: Stage 7 and future relation plans need the same rule when they + start consuming family-shaped data. - **Testing.** Add a `verifier_cleanup` gate `RELATION_INDEXED_EVAL_PREFIX_SITES_CEILING = 0` that fires if any generated stage source still calls `indexed_evals_by_prefix*` or exposes diff --git a/crates/bolt/irdl/compute.mlir b/crates/bolt/irdl/compute.mlir index adc9303bc1..4f4c8aeace 100644 --- a/crates/bolt/irdl/compute.mlir +++ b/crates/bolt/irdl/compute.mlir @@ -640,6 +640,20 @@ irdl.dialect @compute { irdl.operands(result: %result) irdl.results(eval: %eval) } + irdl.operation @sumcheck_eval_family { + %sym = irdl.any + %source = irdl.any + %oracle_family = irdl.any + %count = irdl.any + %evals = irdl.any + irdl.attributes { + "sym_name" = %sym, + "source" = %source, + "oracle_family" = %oracle_family, + "count" = %count, + "evals" = %evals + } + } irdl.operation @sumcheck_instance_result { %input_point = irdl.parametric @compute::@point<> %output_point = irdl.parametric @compute::@point<> diff --git a/crates/bolt/irdl/cpu.mlir b/crates/bolt/irdl/cpu.mlir index 70254d1e73..8d10422534 100644 --- a/crates/bolt/irdl/cpu.mlir +++ b/crates/bolt/irdl/cpu.mlir @@ -570,6 +570,20 @@ irdl.dialect @cpu { irdl.operands(result: %result) irdl.results(eval: %eval) } + irdl.operation @sumcheck_eval_family { + %sym = irdl.any + %source = irdl.any + %oracle_family = irdl.any + %count = irdl.any + %evals = irdl.any + irdl.attributes { + "sym_name" = %sym, + "source" = %source, + "oracle_family" = %oracle_family, + "count" = %count, + "evals" = %evals + } + } irdl.operation @sumcheck_instance_result { %input_point = irdl.parametric @cpu::@point<> %output_point = irdl.parametric @cpu::@point<> diff --git a/crates/bolt/irdl/piop.mlir b/crates/bolt/irdl/piop.mlir index 7de81a43fc..f1cd50bfcf 100644 --- a/crates/bolt/irdl/piop.mlir +++ b/crates/bolt/irdl/piop.mlir @@ -188,6 +188,20 @@ irdl.dialect @piop { irdl.operands(result: %result) irdl.results(eval: %eval) } + irdl.operation @sumcheck_eval_family { + %sym = irdl.any + %source = irdl.any + %oracle_family = irdl.any + %count = irdl.any + %evals = irdl.any + irdl.attributes { + "sym_name" = %sym, + "source" = %source, + "oracle_family" = %oracle_family, + "count" = %count, + "evals" = %evals + } + } irdl.operation @sumcheck_instance_result { %input_point = irdl.parametric @poly::@point<> %output_point = irdl.parametric @poly::@point<> diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index fa8a5682cc..938953ba1d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -13,7 +13,6 @@ use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, - STAGE5_INSTRUCTION_RA_EVAL_FAMILY, STAGE5_TABLE_FLAG_EVAL_FAMILY, }; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_output_claims::{ @@ -308,6 +307,7 @@ impl Stage5CpuProgram { let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); + let mut indexed_eval_families = Vec::new(); let mut output_values = Vec::new(); let mut output_families = Vec::new(); let mut output_product_families = Vec::new(); @@ -524,6 +524,9 @@ impl Stage5CpuProgram { oracle: symbol_attr(op, "oracle")?, }); } + "cpu.sumcheck_eval_family" => { + indexed_eval_families.push(parse_indexed_eval_family(op)?); + } "cpu.structured_polynomial_eval" => { let symbol = string_attr(op, "sym_name")?; let x_point = Stage5StructuredPolynomialPointPlan::from_cpu( @@ -626,11 +629,6 @@ impl Stage5CpuProgram { .map(|claim| claim.claim_value.as_str()), ); } - let indexed_eval_families = if role == Role::Verifier { - stage5_instruction_read_raf_eval_families(&evals)? - } else { - Vec::new() - }; let mut output_claims = if role == Role::Verifier { verifier_output_claims::resolve_output_claims( "stage5", @@ -2545,25 +2543,18 @@ fn expected_batched_output_claim( } } -fn stage5_instruction_read_raf_eval_families( - evals: &[Stage5SumcheckEvalPlan], -) -> Result, EmitError> { - Ok(vec![ - IndexedEvalFamilyPlan::from_indexed_oracles( - STAGE5_TABLE_FLAG_EVAL_FAMILY, - "LookupTableFlag_", - evals - .iter() - .map(|eval| (eval.oracle.as_str(), eval.name.as_str())), - )?, - IndexedEvalFamilyPlan::from_indexed_oracles( - STAGE5_INSTRUCTION_RA_EVAL_FAMILY, - "InstructionRa_", - evals - .iter() - .map(|eval| (eval.oracle.as_str(), eval.name.as_str())), - )?, - ]) +fn parse_indexed_eval_family( + operation: OperationRef<'_, '_>, +) -> Result { + let symbol = string_attr(operation, "sym_name")?; + let evals = symbol_array_attr(operation, "evals")?; + verify_count( + "indexed eval family", + &symbol, + int_attr(operation, "count")?, + evals.len(), + )?; + Ok(IndexedEvalFamilyPlan { symbol, evals }) } fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result<(), EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index f162e8c097..462151fb3e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -334,6 +334,7 @@ impl Stage6CpuProgram { let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); + let mut indexed_eval_families = Vec::new(); let mut output_values = Vec::new(); let mut output_families = Vec::new(); let mut output_product_families = Vec::new(); @@ -551,6 +552,9 @@ impl Stage6CpuProgram { oracle: symbol_attr(op, "oracle")?, }); } + "cpu.sumcheck_eval_family" => { + indexed_eval_families.push(parse_indexed_eval_family(op)?); + } "cpu.structured_polynomial_eval" => { let symbol = string_attr(op, "sym_name")?; let x_point = Stage6StructuredPolynomialPointPlan::from_cpu( @@ -660,11 +664,6 @@ impl Stage6CpuProgram { .map(|claim| claim.claim_value.as_str()), ); } - let indexed_eval_families = if role == Role::Verifier { - stage6_indexed_eval_families(&evals)? - } else { - Vec::new() - }; let mut output_claims = if role == Role::Verifier { verifier_output_claims::resolve_output_claims( "stage6", @@ -2739,14 +2738,18 @@ fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi)) } -fn stage6_indexed_eval_families( - evals: &[Stage6SumcheckEvalPlan], -) -> Result, EmitError> { - Ok(vec![IndexedEvalFamilyPlan::from_indexed_names( - STAGE6_BYTECODE_RA_EVAL_FAMILY, - "stage6.bytecode_read_raf.eval.BytecodeRa_", - evals.iter().map(|eval| eval.name.as_str()), - )?]) +fn parse_indexed_eval_family( + operation: OperationRef<'_, '_>, +) -> Result { + let symbol = string_attr(operation, "sym_name")?; + let evals = symbol_array_attr(operation, "evals")?; + verify_count( + "indexed eval family", + &symbol, + int_attr(operation, "count")?, + evals.len(), + )?; + Ok(IndexedEvalFamilyPlan { symbol, evals }) } fn stage6_bytecode_read_raf_eval_family( @@ -2878,8 +2881,8 @@ mod tests { use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use super::{ - stage6_bytecode_read_raf_eval_family, stage6_indexed_eval_families, stage6_kernel_abi, - Stage6SumcheckEvalPlan, STAGE6_BYTECODE_RA_EVAL_FAMILY, STAGE6_KERNEL_ABIS, + stage6_bytecode_read_raf_eval_family, stage6_kernel_abi, STAGE6_BYTECODE_RA_EVAL_FAMILY, + STAGE6_KERNEL_ABIS, }; #[test] @@ -2897,44 +2900,27 @@ mod tests { } #[test] - fn stage6_bytecode_read_raf_eval_family_is_sorted_by_suffix() -> Result<(), EmitError> { - let evals = vec![ - eval("stage6.bytecode_read_raf.eval.BytecodeRa_2"), - eval("stage6.booleanity.eval.BytecodeRa_0"), - eval("stage6.bytecode_read_raf.eval.BytecodeRa_0"), - eval("stage6.bytecode_read_raf.eval.BytecodeRa_1"), - ]; - - let families = stage6_indexed_eval_families(&evals)?; + fn stage6_bytecode_read_raf_eval_family_uses_explicit_row_order() -> Result<(), EmitError> { + let families = [IndexedEvalFamilyPlan { + symbol: STAGE6_BYTECODE_RA_EVAL_FAMILY.to_owned(), + evals: vec![ + "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), + "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), + ], + }]; let family = stage6_bytecode_read_raf_eval_family(&families)?; assert_eq!( family.evals, vec![ + "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(), "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), - "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(), ] ); Ok(()) } - #[test] - fn stage6_bytecode_read_raf_eval_family_rejects_gaps() { - let evals = vec![ - eval("stage6.bytecode_read_raf.eval.BytecodeRa_0"), - eval("stage6.bytecode_read_raf.eval.BytecodeRa_2"), - ]; - - let result = stage6_indexed_eval_families(&evals); - assert!(result.is_err(), "expected gap error, got {result:?}"); - let error = result - .err() - .map(|error| error.to_string()) - .unwrap_or_default(); - - assert!(error.contains("non-contiguous eval family")); - } - #[test] fn stage6_bytecode_read_raf_eval_family_requires_explicit_plan_row() { let families = [IndexedEvalFamilyPlan { @@ -2951,14 +2937,4 @@ mod tests { "missing eval family `{STAGE6_BYTECODE_RA_EVAL_FAMILY}`" ))); } - - fn eval(name: &'static str) -> Stage6SumcheckEvalPlan { - Stage6SumcheckEvalPlan { - symbol: name.to_owned(), - source: "stage6.sumcheck".to_owned(), - name: name.to_owned(), - index: 0, - oracle: "BytecodeRa_0".to_owned(), - } - } } diff --git a/crates/bolt/src/protocols/jolt/phases/commitment.rs b/crates/bolt/src/protocols/jolt/phases/commitment.rs index ba8ea4ed42..9deb69df0a 100644 --- a/crates/bolt/src/protocols/jolt/phases/commitment.rs +++ b/crates/bolt/src/protocols/jolt/phases/commitment.rs @@ -894,6 +894,16 @@ pub fn lower_compute_to_cpu<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "compute.sumcheck_eval_family" => { + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs(op, &["source", "oracle_family", "count", "evals"])?; + context.append_op_with_owned_attrs( + &cpu, + "cpu.sumcheck_eval_family", + Some(&symbol), + &attrs, + )?; + } "compute.sumcheck_instance_result" => { let operands = lowered_operands(op, &value_map)?; let symbol = string_attr(op, "sym_name")?; diff --git a/crates/bolt/src/protocols/jolt/phases/lowering.rs b/crates/bolt/src/protocols/jolt/phases/lowering.rs index b5342d849d..6740720543 100644 --- a/crates/bolt/src/protocols/jolt/phases/lowering.rs +++ b/crates/bolt/src/protocols/jolt/phases/lowering.rs @@ -401,6 +401,16 @@ pub(super) fn lower_party_to_compute<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "piop.sumcheck_eval_family" => { + let symbol = string_attr(op, "sym_name")?; + let attrs = copy_attrs(op, &["source", "oracle_family", "count", "evals"])?; + context.append_op_with_owned_attrs( + &compute, + "compute.sumcheck_eval_family", + Some(&symbol), + &attrs, + )?; + } "piop.sumcheck_instance_result" => { let operands = lowered_operands(op, &value_map, 0)?; let symbol = string_attr(op, "sym_name")?; diff --git a/crates/bolt/src/protocols/jolt/phases/stage1.rs b/crates/bolt/src/protocols/jolt/phases/stage1.rs index 6018b09fa7..01e57d0a50 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage1.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage1.rs @@ -821,6 +821,16 @@ pub fn resolve_compute_kernels<'c>( )?; insert_result_mapping(&mut value_map, op, operation, 0, 0)?; } + "compute.sumcheck_eval_family" => { + let attrs = copy_attrs(op, &["source", "oracle_family", "count", "evals"])?; + let symbol = string_attr(op, "sym_name")?; + context.append_op_with_owned_attrs( + &kernelized, + "compute.sumcheck_eval_family", + Some(&symbol), + &attrs, + )?; + } "compute.sumcheck_instance_result" => { let operands = lowered_operands(op, &value_map, 0)?; let attrs = copy_attrs( diff --git a/crates/bolt/src/protocols/jolt/phases/stage5.rs b/crates/bolt/src/protocols/jolt/phases/stage5.rs index a4807f0564..fdd3a9b3a6 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage5.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage5.rs @@ -741,10 +741,12 @@ fn append_stage5_output_openings<'c, 'a>( params.log_t, instruction.0, )?; + let mut table_flag_eval_symbols = Vec::with_capacity(params.lookup_table_count); for index in 0..params.lookup_table_count { let oracle = format!("LookupTableFlag_{index}"); let symbol = format!("stage5.instruction_read_raf.opening.{oracle}"); let eval_symbol = format!("stage5.instruction_read_raf.eval.{oracle}"); + table_flag_eval_symbols.push(eval_symbol.clone()); let eval = append_sumcheck_eval( context, module, @@ -769,7 +771,16 @@ fn append_stage5_output_openings<'c, 'a>( }, )?); } + append_sumcheck_eval_family( + context, + module, + "stage5.instruction_read_raf.eval.LookupTableFlag", + "stage5.sumcheck", + "LookupTableFlag", + &table_flag_eval_symbols, + )?; + let mut instruction_ra_eval_symbols = Vec::with_capacity(params.instruction_ra_virtual_d); for index in 0..params.instruction_ra_virtual_d { let oracle = format!("InstructionRa_{index}"); let symbol = format!("stage5.instruction_read_raf.opening.{oracle}"); @@ -791,6 +802,7 @@ fn append_stage5_output_openings<'c, 'a>( &[address_chunk, instruction_cycle], )?; let eval_symbol = format!("stage5.instruction_read_raf.eval.{oracle}"); + instruction_ra_eval_symbols.push(eval_symbol.clone()); let eval = append_sumcheck_eval( context, module, @@ -815,6 +827,14 @@ fn append_stage5_output_openings<'c, 'a>( }, )?); } + append_sumcheck_eval_family( + context, + module, + "stage5.instruction_read_raf.eval.InstructionRa", + "stage5.sumcheck", + "InstructionRa", + &instruction_ra_eval_symbols, + )?; let raf_flag_eval_index = params.lookup_table_count + params.instruction_ra_virtual_d; let raf_flag_eval = append_sumcheck_eval( @@ -1341,6 +1361,29 @@ fn append_sumcheck_eval<'c, 'a>( first_result(op, "piop.sumcheck_eval") } +fn append_sumcheck_eval_family( + context: &MeliorContext, + module: &BoltModule<'_, Protocol>, + symbol: &str, + source: &str, + oracle_family: &str, + evals: &[String], +) -> Result<(), MlirError> { + let eval_symbols = evals.iter().map(String::as_str).collect::>(); + context.append_op( + module, + "piop.sumcheck_eval_family", + Some(symbol), + &[ + ("source", &format!("@{}", source)), + ("oracle_family", &format!("@{}", oracle_family)), + ("count", &int_attr(eval_symbols.len())), + ("evals", &symbol_array_attr(&eval_symbols)), + ], + )?; + Ok(()) +} + fn append_point_slice<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, diff --git a/crates/bolt/src/protocols/jolt/phases/stage6.rs b/crates/bolt/src/protocols/jolt/phases/stage6.rs index 96081f7045..bae00ce176 100644 --- a/crates/bolt/src/protocols/jolt/phases/stage6.rs +++ b/crates/bolt/src/protocols/jolt/phases/stage6.rs @@ -1433,9 +1433,11 @@ fn append_stage6_output_openings<'c, 'a>( params.log_t, bytecode.0, )?; + let mut bytecode_ra_eval_symbols = Vec::with_capacity(params.bytecode_d); for index in 0..params.bytecode_d { let oracle = format!("BytecodeRa_{index}"); let eval_symbol = format!("stage6.bytecode_read_raf.eval.{oracle}"); + bytecode_ra_eval_symbols.push(eval_symbol.clone()); let eval = append_sumcheck_eval( context, module, @@ -1479,6 +1481,14 @@ fn append_stage6_output_openings<'c, 'a>( }, )?); } + append_sumcheck_eval_family( + context, + module, + "stage6.bytecode_read_raf.eval.BytecodeRa", + "stage6.sumcheck", + "BytecodeRa", + &bytecode_ra_eval_symbols, + )?; let mut eval_index = 0; for index in 0..params.instruction_d { @@ -2405,6 +2415,29 @@ fn append_sumcheck_eval<'c, 'a>( first_result(op, "piop.sumcheck_eval") } +fn append_sumcheck_eval_family( + context: &MeliorContext, + module: &BoltModule<'_, Protocol>, + symbol: &str, + source: &str, + oracle_family: &str, + evals: &[String], +) -> Result<(), MlirError> { + let eval_symbols = evals.iter().map(String::as_str).collect::>(); + context.append_op( + module, + "piop.sumcheck_eval_family", + Some(symbol), + &[ + ("source", &format!("@{}", source)), + ("oracle_family", &format!("@{}", oracle_family)), + ("count", &int_attr(eval_symbols.len())), + ("evals", &symbol_array_attr(&eval_symbols)), + ], + )?; + Ok(()) +} + fn append_point_slice<'c, 'a>( context: &'c MeliorContext, module: &'a BoltModule<'c, Protocol>, diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index d207b3c2e3..c33025191b 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -368,7 +368,7 @@ mod tests { "LookupTableFlag_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0", ), - ])?; + ]); let plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&families)?; assert_eq!( @@ -400,7 +400,7 @@ mod tests { "InstructionRa_0", "stage5.instruction_read_raf.eval.InstructionRa_0", ), - ])?; + ]); let plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&families)?; let output_plan = plan.output_claim_plan(); @@ -455,32 +455,6 @@ mod tests { Ok(()) } - #[test] - fn instruction_read_raf_plan_rejects_non_contiguous_eval_families() -> Result<(), EmitError> { - let error = match instruction_read_raf_families([ - ( - "LookupTableFlag_1", - "stage5.instruction_read_raf.eval.LookupTableFlag_1", - ), - ( - "InstructionRa_0", - "stage5.instruction_read_raf.eval.InstructionRa_0", - ), - ]) { - Ok(_) => { - return Err(EmitError::new( - "non-contiguous table flag family should fail planning", - )); - } - Err(error) => error, - }; - - assert!(error.to_string().contains( - "non-contiguous eval family `stage5.instruction_read_raf.eval.LookupTableFlag`" - )); - Ok(()) - } - #[test] fn instruction_read_raf_plan_requires_explicit_eval_family_rows() { let families = [IndexedEvalFamilyPlan { @@ -500,19 +474,31 @@ mod tests { fn instruction_read_raf_families<'a>( evals: impl IntoIterator, - ) -> Result, EmitError> { + ) -> Vec { let evals = evals.into_iter().collect::>(); - Ok(vec![ - IndexedEvalFamilyPlan::from_indexed_oracles( - STAGE5_TABLE_FLAG_EVAL_FAMILY, - "LookupTableFlag_", - evals.iter().copied(), - )?, - IndexedEvalFamilyPlan::from_indexed_oracles( - STAGE5_INSTRUCTION_RA_EVAL_FAMILY, - "InstructionRa_", - evals.iter().copied(), - )?, - ]) + vec![ + IndexedEvalFamilyPlan { + symbol: STAGE5_TABLE_FLAG_EVAL_FAMILY.to_owned(), + evals: indexed_names("LookupTableFlag_", &evals), + }, + IndexedEvalFamilyPlan { + symbol: STAGE5_INSTRUCTION_RA_EVAL_FAMILY.to_owned(), + evals: indexed_names("InstructionRa_", &evals), + }, + ] + } + + fn indexed_names(prefix: &str, evals: &[(&str, &str)]) -> Vec { + let mut names = evals + .iter() + .filter_map(|(oracle, name)| { + oracle + .strip_prefix(prefix) + .and_then(|index| index.parse::().ok()) + .map(|index| (index, (*name).to_owned())) + }) + .collect::>(); + names.sort_by_key(|(index, _)| *index); + names.into_iter().map(|(_, name)| name).collect() } } diff --git a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs index e46f9673eb..182fc8607c 100644 --- a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs +++ b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs @@ -1,5 +1,3 @@ -use std::collections::BTreeMap; - use crate::emit::rust::{push_format, EmitError}; #[derive(Clone, Debug, PartialEq, Eq)] @@ -23,44 +21,6 @@ impl IndexedEvalFamilyPlan { Ok(family) } - pub(crate) fn from_indexed_oracles<'a>( - symbol: &str, - oracle_prefix: &str, - evals: impl IntoIterator, - ) -> Result { - let evals = indexed_values( - symbol, - "eval oracle", - oracle_prefix, - evals - .into_iter() - .map(|(oracle, name)| (oracle, name.to_owned())), - )?; - Ok(Self { - symbol: symbol.to_owned(), - evals, - }) - } - - pub(crate) fn from_indexed_names<'a>( - symbol: &str, - name_prefix: &str, - eval_names: impl IntoIterator, - ) -> Result { - let evals = indexed_values( - symbol, - "eval name", - name_prefix, - eval_names - .into_iter() - .map(|eval_name| (eval_name, eval_name.to_owned())), - )?; - Ok(Self { - symbol: symbol.to_owned(), - evals, - }) - } - pub(crate) fn emit_runtime_constant( &self, visibility: &str, @@ -92,87 +52,42 @@ impl IndexedEvalFamilyPlan { } } -fn indexed_values<'a>( - symbol: &str, - indexed_value_kind: &str, - prefix: &str, - values: impl IntoIterator, -) -> Result, EmitError> { - let mut indexed_values = BTreeMap::new(); - for (indexed_name, value) in values { - let Some(suffix) = indexed_name.strip_prefix(prefix) else { - continue; - }; - let index = suffix.parse::().map_err(|_| { - EmitError::new(format!( - "invalid indexed {indexed_value_kind} `{indexed_name}` for family `{symbol}`" - )) - })?; - if indexed_values.insert(index, value).is_some() { - return Err(EmitError::new(format!( - "duplicate indexed {indexed_value_kind} `{indexed_name}` for family `{symbol}`" - ))); - } - } - if indexed_values.is_empty() { - return Err(EmitError::new(format!("missing eval family `{symbol}`"))); - } - - let mut evals = Vec::with_capacity(indexed_values.len()); - for (expected, (actual, value)) in indexed_values.into_iter().enumerate() { - if expected != actual { - return Err(EmitError::new(format!( - "non-contiguous eval family `{symbol}`: expected index {expected}, got {actual}" - ))); - } - evals.push(value); - } - Ok(evals) -} - fn rust_str(value: &str) -> String { format!("{value:?}") } #[cfg(test)] mod tests { - use crate::emit::rust::EmitError; - use super::IndexedEvalFamilyPlan; #[test] - fn named_eval_family_sorts_indexed_oracles() -> Result<(), EmitError> { - let family = IndexedEvalFamilyPlan::from_indexed_oracles( - "stage.eval.LookupTableFlag", - "LookupTableFlag_", - [ - ("LookupTableFlag_1", "stage.eval.LookupTableFlag_1"), - ("Other_0", "stage.eval.Other_0"), - ("LookupTableFlag_0", "stage.eval.LookupTableFlag_0"), - ], - )?; + fn find_rejects_missing_families() { + let error = IndexedEvalFamilyPlan::find(&[], "stage.eval.LookupTableFlag") + .err() + .map(|error| error.to_string()) + .unwrap_or_default(); - assert_eq!( - family.evals, - vec![ - "stage.eval.LookupTableFlag_0".to_owned(), - "stage.eval.LookupTableFlag_1".to_owned(), - ] - ); - Ok(()) + assert!(error.contains("missing eval family `stage.eval.LookupTableFlag`")); } #[test] - fn named_eval_family_rejects_gaps() { - let error = IndexedEvalFamilyPlan::from_indexed_names( - "stage.eval.BytecodeRa", - "stage.eval.BytecodeRa_", - ["stage.eval.BytecodeRa_0", "stage.eval.BytecodeRa_2"], - ) - .err() - .map(|error| error.to_string()) - .unwrap_or_default(); + fn find_rejects_duplicate_families() { + let families = [ + IndexedEvalFamilyPlan { + symbol: "stage.eval.BytecodeRa".to_owned(), + evals: vec!["stage.eval.BytecodeRa_0".to_owned()], + }, + IndexedEvalFamilyPlan { + symbol: "stage.eval.BytecodeRa".to_owned(), + evals: vec!["stage.eval.BytecodeRa_1".to_owned()], + }, + ]; + + let error = IndexedEvalFamilyPlan::find(&families, "stage.eval.BytecodeRa") + .err() + .map(|error| error.to_string()) + .unwrap_or_default(); - assert!(error.contains("non-contiguous eval family `stage.eval.BytecodeRa`")); + assert!(error.contains("duplicate eval family `stage.eval.BytecodeRa`")); } } diff --git a/crates/bolt/src/schema.rs b/crates/bolt/src/schema.rs index f46cf7ad57..710a3fc3ce 100644 --- a/crates/bolt/src/schema.rs +++ b/crates/bolt/src/schema.rs @@ -386,6 +386,14 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( )?; require_shape(operation, 1, 1) } + "piop.sumcheck_eval_family" => { + require_attrs( + operation, + &["sym_name", "source", "oracle_family", "count", "evals"], + )?; + require_shape(operation, 0, 0)?; + require_counted_symbols(operation, "evals") + } "piop.sumcheck_instance_result" => { require_attrs( operation, @@ -758,6 +766,14 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( )?; require_shape(operation, 1, 1) } + "compute.sumcheck_eval_family" => { + require_attrs( + operation, + &["sym_name", "source", "oracle_family", "count", "evals"], + )?; + require_shape(operation, 0, 0)?; + require_counted_symbols(operation, "evals") + } "compute.sumcheck_instance_result" => { require_attrs( operation, @@ -1113,6 +1129,14 @@ fn validate_op(operation: OperationRef<'_, '_>, _phase: ModulePhase) -> Result<( )?; require_shape(operation, 1, 1) } + "cpu.sumcheck_eval_family" => { + require_attrs( + operation, + &["sym_name", "source", "oracle_family", "count", "evals"], + )?; + require_shape(operation, 0, 0)?; + require_counted_symbols(operation, "evals") + } "cpu.sumcheck_instance_result" => { require_attrs( operation, @@ -1693,6 +1717,28 @@ fn require_counted_operands( Ok(()) } +fn require_counted_symbols( + operation: OperationRef<'_, '_>, + ordered_attr: &str, +) -> Result<(), SchemaError> { + let count = int_attr(operation, "count")?; + let ordered = symbol_array_attr(operation, ordered_attr)?; + if count == 0 { + return Err(SchemaError::new(format!( + "{} attr `{ordered_attr}` must contain at least one symbol", + operation_name(operation) + ))); + } + if ordered.len() != count { + return Err(SchemaError::new(format!( + "{} attr `{ordered_attr}` length {} does not match count {count}", + operation_name(operation), + ordered.len() + ))); + } + Ok(()) +} + pub(crate) fn require_attrs( operation: OperationRef<'_, '_>, attrs: &[&str], diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 424e0122a3..2c8a94441c 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -328,6 +328,35 @@ fn protocol_schema_accepts_explicit_sumcheck_and_opening_flow() { assert!(text.contains("\"pcs.batch_open\"(%")); } +#[test] +fn protocol_schema_rejects_eval_family_count_mismatch() { + let context = MeliorContext::new(); + let protocol = context + .parse_module::(&explicit_sumcheck_protocol_with_eval_family( + 2, + "[@stage1.outer.eval]", + )) + .expect("parse protocol with mismatched eval family"); + + let error = verify_protocol_schema(&protocol).expect_err("eval family count mismatch"); + assert!(error + .to_string() + .contains("piop.sumcheck_eval_family attr `evals` length 1 does not match count 2")); +} + +#[test] +fn protocol_schema_rejects_empty_eval_family() { + let context = MeliorContext::new(); + let protocol = context + .parse_module::(&explicit_sumcheck_protocol_with_eval_family(0, "[]")) + .expect("parse protocol with empty eval family"); + + let error = verify_protocol_schema(&protocol).expect_err("empty eval family rejected"); + assert!(error + .to_string() + .contains("piop.sumcheck_eval_family attr `evals` must contain at least one symbol")); +} + #[test] fn opening_batch_schema_rejects_hidden_or_reordered_claims() { let context = MeliorContext::new(); @@ -3576,6 +3605,16 @@ module @explicit.sumcheck attributes {bolt.phase = "protocol"} { "# } +fn explicit_sumcheck_protocol_with_eval_family(count: usize, evals: &str) -> String { + explicit_sumcheck_protocol().replace( + r#" %opening = "pcs.opening_claim""#, + &format!( + r#" "piop.sumcheck_eval_family"() {{count = {count} : i64, evals = {evals}, oracle_family = @RdInc, source = @stage1.outer.sumcheck, sym_name = "stage1.outer.eval.family"}} : () -> () + %opening = "pcs.opening_claim""# + ), + ) +} + fn explicit_sumcheck_compute() -> &'static str { r#" module @explicit.sumcheck attributes {bolt.phase = "compute", bolt.role = "prover"} { From 485de6f5c309b2f0739387ebd9040407d211eb4a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 13:41:23 -0600 Subject: [PATCH 088/171] refactor(bolt): split verifier value sources Move scalar and point verifier source registries into a dedicated verifier_values module so output-claim planning consumes value-domain ownership instead of defining it. This sets up the S3 value-graph work without changing generated verifier behavior. --- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 8 + .../src/protocols/jolt/emit/rust/stage3.rs | 29 ++-- .../src/protocols/jolt/emit/rust/stage4.rs | 29 ++-- .../src/protocols/jolt/emit/rust/stage5.rs | 45 +++--- .../src/protocols/jolt/emit/rust/stage6.rs | 47 +++--- .../src/protocols/jolt/emit/rust/stage7.rs | 37 ++--- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../protocols/jolt/verifier_output_claims.rs | 146 +----------------- .../src/protocols/jolt/verifier_values.rs | 141 +++++++++++++++++ 9 files changed, 252 insertions(+), 231 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_values.rs diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index cfec88c8af..ef2fa85cf7 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -577,6 +577,14 @@ The important design point is that this is not "add more variants to `FieldExprKind`"; it is a typed graph over scalar, point, field-vector, and eval-family values. +### Current status + +The scalar/point source registry has been moved out of +`verifier_output_claims` into `verifier_values`. This is only the foundation: +it gives scalar and point domains an explicit home, but field-vector values, +eval-family values, and relation-output execution are not yet lowered through a +single typed graph. + ### Dialect changes Extend `crates/bolt/irdl/compute.mlir` (no new dialect; these are dataflow diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 1f6f4f518e..a2e6b04c9c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -14,6 +14,7 @@ use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputClaimPlan as Stage3SumcheckOutputClaimPlan, }; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] @@ -704,57 +705,57 @@ impl Stage3CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> verifier_output_claims::VerifierScalarSourceSet { - let mut values = verifier_output_claims::VerifierScalarSourceSet::default(); + fn field_value_symbols(&self) -> verifier_values::VerifierScalarSourceSet { + let mut values = verifier_values::VerifierScalarSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - verifier_output_claims::VerifierScalarSourceKind::OpeningInput, + verifier_values::VerifierScalarSourceKind::OpeningInput, ); values.extend( self.field_constants.iter().map(|constant| &constant.symbol), - verifier_output_claims::VerifierScalarSourceKind::FieldConstant, + verifier_values::VerifierScalarSourceKind::FieldConstant, ); values.extend( self.transcript_squeezes .iter() .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), - verifier_output_claims::VerifierScalarSourceKind::TranscriptScalar, + verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), - verifier_output_claims::VerifierScalarSourceKind::FieldExpr, + verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( self.evals.iter().map(|eval| &eval.symbol), - verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, + verifier_values::VerifierScalarSourceKind::SumcheckEval, ); values.extend( self.output_values.iter().map(|value| &value.symbol), - verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values } - fn point_value_symbols(&self) -> verifier_output_claims::VerifierPointSourceSet { - let mut values = verifier_output_claims::VerifierPointSourceSet::default(); + fn point_value_symbols(&self) -> verifier_values::VerifierPointSourceSet { + let mut values = verifier_values::VerifierPointSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - verifier_output_claims::VerifierPointSourceKind::OpeningInput, + verifier_values::VerifierPointSourceKind::OpeningInput, ); values.extend( self.instance_results .iter() .map(|instance| &instance.symbol), - verifier_output_claims::VerifierPointSourceKind::SumcheckInstance, + verifier_values::VerifierPointSourceKind::SumcheckInstance, ); values.extend( self.point_slices.iter().map(|slice| &slice.symbol), - verifier_output_claims::VerifierPointSourceKind::PointSlice, + verifier_values::VerifierPointSourceKind::PointSlice, ); values.extend( self.point_concats.iter().map(|concat| &concat.symbol), - verifier_output_claims::VerifierPointSourceKind::PointConcat, + verifier_values::VerifierPointSourceKind::PointConcat, ); values } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index d9148f8cea..701e392907 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -19,6 +19,7 @@ use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputClaimPlan as Stage4SumcheckOutputClaimPlan, }; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] @@ -725,57 +726,57 @@ impl Stage4CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> verifier_output_claims::VerifierScalarSourceSet { - let mut values = verifier_output_claims::VerifierScalarSourceSet::default(); + fn field_value_symbols(&self) -> verifier_values::VerifierScalarSourceSet { + let mut values = verifier_values::VerifierScalarSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - verifier_output_claims::VerifierScalarSourceKind::OpeningInput, + verifier_values::VerifierScalarSourceKind::OpeningInput, ); values.extend( self.field_constants.iter().map(|constant| &constant.symbol), - verifier_output_claims::VerifierScalarSourceKind::FieldConstant, + verifier_values::VerifierScalarSourceKind::FieldConstant, ); values.extend( self.transcript_squeezes .iter() .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), - verifier_output_claims::VerifierScalarSourceKind::TranscriptScalar, + verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); values.extend( self.output_values.iter().map(|value| &value.symbol), - verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), - verifier_output_claims::VerifierScalarSourceKind::FieldExpr, + verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( self.evals.iter().map(|eval| &eval.symbol), - verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, + verifier_values::VerifierScalarSourceKind::SumcheckEval, ); values } - fn point_value_symbols(&self) -> verifier_output_claims::VerifierPointSourceSet { - let mut values = verifier_output_claims::VerifierPointSourceSet::default(); + fn point_value_symbols(&self) -> verifier_values::VerifierPointSourceSet { + let mut values = verifier_values::VerifierPointSourceSet::default(); values.extend( self.instance_results .iter() .map(|instance| &instance.symbol), - verifier_output_claims::VerifierPointSourceKind::SumcheckInstance, + verifier_values::VerifierPointSourceKind::SumcheckInstance, ); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - verifier_output_claims::VerifierPointSourceKind::OpeningInput, + verifier_values::VerifierPointSourceKind::OpeningInput, ); values.extend( self.point_slices.iter().map(|slice| &slice.symbol), - verifier_output_claims::VerifierPointSourceKind::PointSlice, + verifier_values::VerifierPointSourceKind::PointSlice, ); values.extend( self.point_concats.iter().map(|concat| &concat.symbol), - verifier_output_claims::VerifierPointSourceKind::PointConcat, + verifier_values::VerifierPointSourceKind::PointConcat, ); values } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 938953ba1d..61543a6fe0 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -27,6 +27,7 @@ use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputProductFamilyPlan as Stage5SumcheckOutputProductFamilyPlan, }; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] @@ -775,103 +776,103 @@ impl Stage5CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> verifier_output_claims::VerifierScalarSourceSet { - let mut values = verifier_output_claims::VerifierScalarSourceSet::default(); + fn field_value_symbols(&self) -> verifier_values::VerifierScalarSourceSet { + let mut values = verifier_values::VerifierScalarSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - verifier_output_claims::VerifierScalarSourceKind::OpeningInput, + verifier_values::VerifierScalarSourceKind::OpeningInput, ); values.extend( self.field_constants.iter().map(|constant| &constant.symbol), - verifier_output_claims::VerifierScalarSourceKind::FieldConstant, + verifier_values::VerifierScalarSourceKind::FieldConstant, ); values.extend( self.transcript_squeezes .iter() .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), - verifier_output_claims::VerifierScalarSourceKind::TranscriptScalar, + verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); values.extend( self.output_values.iter().map(|value| &value.symbol), - verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( self.output_claims .iter() .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), - verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( self.output_families.iter().map(|family| &family.symbol), - verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, + verifier_values::VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( self.output_product_families .iter() .map(|family| &family.symbol), - verifier_output_claims::VerifierScalarSourceKind::OutputProductFamily, + verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); values.extend( self.output_function_families .iter() .map(|family| &family.symbol), - verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, + verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, ); values.extend( self.output_claims .iter() .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), - verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, + verifier_values::VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( self.output_claims .iter() .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), - verifier_output_claims::VerifierScalarSourceKind::OutputProductFamily, + verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); values.extend( self.output_claims .iter() .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), - verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, + verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), - verifier_output_claims::VerifierScalarSourceKind::FieldExpr, + verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( self.output_claims .iter() .flat_map(|claim| claim.local_scalars.iter()), - verifier_output_claims::VerifierScalarSourceKind::PointDerived, + verifier_values::VerifierScalarSourceKind::PointDerived, ); values.extend( self.evals.iter().map(|eval| &eval.symbol), - verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, + verifier_values::VerifierScalarSourceKind::SumcheckEval, ); values } - fn point_value_symbols(&self) -> verifier_output_claims::VerifierPointSourceSet { - let mut values = verifier_output_claims::VerifierPointSourceSet::default(); + fn point_value_symbols(&self) -> verifier_values::VerifierPointSourceSet { + let mut values = verifier_values::VerifierPointSourceSet::default(); values.extend( self.instance_results .iter() .map(|instance| &instance.symbol), - verifier_output_claims::VerifierPointSourceKind::SumcheckInstance, + verifier_values::VerifierPointSourceKind::SumcheckInstance, ); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - verifier_output_claims::VerifierPointSourceKind::OpeningInput, + verifier_values::VerifierPointSourceKind::OpeningInput, ); values.extend( self.point_slices.iter().map(|slice| &slice.symbol), - verifier_output_claims::VerifierPointSourceKind::PointSlice, + verifier_values::VerifierPointSourceKind::PointSlice, ); values.extend( self.point_concats.iter().map(|concat| &concat.symbol), - verifier_output_claims::VerifierPointSourceKind::PointConcat, + verifier_values::VerifierPointSourceKind::PointConcat, ); values } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 462151fb3e..6232fe79c9 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -28,6 +28,7 @@ use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputProductFamilyPlan as Stage6SumcheckOutputProductFamilyPlan, }; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; use super::plan_tokens::{ @@ -810,107 +811,107 @@ impl Stage6CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> verifier_output_claims::VerifierScalarSourceSet { - let mut values = verifier_output_claims::VerifierScalarSourceSet::default(); + fn field_value_symbols(&self) -> verifier_values::VerifierScalarSourceSet { + let mut values = verifier_values::VerifierScalarSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - verifier_output_claims::VerifierScalarSourceKind::OpeningInput, + verifier_values::VerifierScalarSourceKind::OpeningInput, ); values.extend( self.field_constants.iter().map(|constant| &constant.symbol), - verifier_output_claims::VerifierScalarSourceKind::FieldConstant, + verifier_values::VerifierScalarSourceKind::FieldConstant, ); values.extend( self.transcript_squeezes .iter() .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), - verifier_output_claims::VerifierScalarSourceKind::TranscriptScalar, + verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); values.extend( self.output_values.iter().map(|value| &value.symbol), - verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( self.output_claims .iter() .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), - verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( self.output_families.iter().map(|family| &family.symbol), - verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, + verifier_values::VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( self.output_product_families .iter() .map(|family| &family.symbol), - verifier_output_claims::VerifierScalarSourceKind::OutputProductFamily, + verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); values.extend( self.output_function_families .iter() .map(|family| &family.symbol), - verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, + verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, ); values.extend( self.output_claims .iter() .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), - verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, + verifier_values::VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( self.output_claims .iter() .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), - verifier_output_claims::VerifierScalarSourceKind::OutputProductFamily, + verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); values.extend( self.output_claims .iter() .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), - verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, + verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), - verifier_output_claims::VerifierScalarSourceKind::FieldExpr, + verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( self.output_claims .iter() .flat_map(|claim| claim.local_scalars.iter()), - verifier_output_claims::VerifierScalarSourceKind::PointDerived, + verifier_values::VerifierScalarSourceKind::PointDerived, ); values.extend( self.evals.iter().map(|eval| &eval.symbol), - verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, + verifier_values::VerifierScalarSourceKind::SumcheckEval, ); values } - fn point_value_symbols(&self) -> verifier_output_claims::VerifierPointSourceSet { - let mut values = verifier_output_claims::VerifierPointSourceSet::default(); + fn point_value_symbols(&self) -> verifier_values::VerifierPointSourceSet { + let mut values = verifier_values::VerifierPointSourceSet::default(); values.extend( self.instance_results .iter() .map(|instance| &instance.symbol), - verifier_output_claims::VerifierPointSourceKind::SumcheckInstance, + verifier_values::VerifierPointSourceKind::SumcheckInstance, ); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - verifier_output_claims::VerifierPointSourceKind::OpeningInput, + verifier_values::VerifierPointSourceKind::OpeningInput, ); values.extend( self.point_zeros.iter().map(|zero| &zero.symbol), - verifier_output_claims::VerifierPointSourceKind::PointZero, + verifier_values::VerifierPointSourceKind::PointZero, ); values.extend( self.point_slices.iter().map(|slice| &slice.symbol), - verifier_output_claims::VerifierPointSourceKind::PointSlice, + verifier_values::VerifierPointSourceKind::PointSlice, ); values.extend( self.point_concats.iter().map(|concat| &concat.symbol), - verifier_output_claims::VerifierPointSourceKind::PointConcat, + verifier_values::VerifierPointSourceKind::PointConcat, ); values } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index bff3b71f17..d15b63d42f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -23,6 +23,7 @@ use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputProductFamilyPlan as Stage7SumcheckOutputProductFamilyPlan, }; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; use super::plan_tokens::{ @@ -778,77 +779,77 @@ impl Stage7CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> verifier_output_claims::VerifierScalarSourceSet { - let mut values = verifier_output_claims::VerifierScalarSourceSet::default(); + fn field_value_symbols(&self) -> verifier_values::VerifierScalarSourceSet { + let mut values = verifier_values::VerifierScalarSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - verifier_output_claims::VerifierScalarSourceKind::OpeningInput, + verifier_values::VerifierScalarSourceKind::OpeningInput, ); values.extend( self.field_constants.iter().map(|constant| &constant.symbol), - verifier_output_claims::VerifierScalarSourceKind::FieldConstant, + verifier_values::VerifierScalarSourceKind::FieldConstant, ); values.extend( self.transcript_squeezes .iter() .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) .map(|squeeze| &squeeze.symbol), - verifier_output_claims::VerifierScalarSourceKind::TranscriptScalar, + verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), - verifier_output_claims::VerifierScalarSourceKind::FieldExpr, + verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( self.evals.iter().map(|eval| &eval.symbol), - verifier_output_claims::VerifierScalarSourceKind::SumcheckEval, + verifier_values::VerifierScalarSourceKind::SumcheckEval, ); values.extend( self.output_values.iter().map(|value| &value.symbol), - verifier_output_claims::VerifierScalarSourceKind::StructuredPolynomialEval, + verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( self.output_families.iter().map(|family| &family.symbol), - verifier_output_claims::VerifierScalarSourceKind::OutputEvalFamily, + verifier_values::VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( self.output_product_families .iter() .map(|family| &family.symbol), - verifier_output_claims::VerifierScalarSourceKind::OutputProductFamily, + verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); values.extend( self.output_function_families .iter() .map(|family| &family.symbol), - verifier_output_claims::VerifierScalarSourceKind::OutputFunctionFamily, + verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, ); values } - fn point_value_symbols(&self) -> verifier_output_claims::VerifierPointSourceSet { - let mut values = verifier_output_claims::VerifierPointSourceSet::default(); + fn point_value_symbols(&self) -> verifier_values::VerifierPointSourceSet { + let mut values = verifier_values::VerifierPointSourceSet::default(); values.extend( self.instance_results .iter() .map(|instance| &instance.symbol), - verifier_output_claims::VerifierPointSourceKind::SumcheckInstance, + verifier_values::VerifierPointSourceKind::SumcheckInstance, ); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), - verifier_output_claims::VerifierPointSourceKind::OpeningInput, + verifier_values::VerifierPointSourceKind::OpeningInput, ); values.extend( self.point_zeros.iter().map(|zero| &zero.symbol), - verifier_output_claims::VerifierPointSourceKind::PointZero, + verifier_values::VerifierPointSourceKind::PointZero, ); values.extend( self.point_slices.iter().map(|slice| &slice.symbol), - verifier_output_claims::VerifierPointSourceKind::PointSlice, + verifier_values::VerifierPointSourceKind::PointSlice, ); values.extend( self.point_concats.iter().map(|concat| &concat.symbol), - verifier_output_claims::VerifierPointSourceKind::PointConcat, + verifier_values::VerifierPointSourceKind::PointConcat, ); values } diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index 55ffdc075d..f494a5dda8 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -10,6 +10,7 @@ pub mod validate; pub(crate) mod verifier_eval_families; pub(crate) mod verifier_output_claims; pub(crate) mod verifier_plan; +pub(crate) mod verifier_values; pub use artifacts::{ assemble_jolt_generated_crates, assemble_jolt_workspace_generated_crates, jolt_artifact_config, diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index 94d4fcfb27..c8a41f9cf7 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -5,6 +5,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::EmitError; use crate::ir::string_attribute_value; +use crate::protocols::jolt::verifier_values::{VerifierPointSourceSet, VerifierScalarSourceSet}; use crate::schema::operation_name; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -512,144 +513,6 @@ pub trait FieldExprDependencies { fn operands(&self) -> &[String]; } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum VerifierScalarSourceKind { - OpeningInput, - FieldConstant, - TranscriptScalar, - FieldExpr, - PointDerived, - SumcheckEval, - StructuredPolynomialEval, - OutputEvalFamily, - OutputProductFamily, - OutputFunctionFamily, -} - -#[derive(Clone, Debug, Default, PartialEq, Eq)] -pub struct VerifierScalarSourceSet { - symbols: BTreeMap, - conflicts: Vec>, -} - -impl VerifierScalarSourceSet { - pub fn insert(&mut self, symbol: &str, kind: VerifierScalarSourceKind) { - match self.symbols.entry(symbol.to_owned()) { - std::collections::btree_map::Entry::Vacant(entry) => { - let _entry = entry.insert(kind); - } - std::collections::btree_map::Entry::Occupied(entry) => { - let existing = *entry.get(); - if existing != kind { - self.conflicts.push(VerifierSourceConflict { - symbol: symbol.to_owned(), - existing, - incoming: kind, - }); - } - } - } - } - - pub fn extend<'a>( - &mut self, - symbols: impl IntoIterator, - kind: VerifierScalarSourceKind, - ) { - for symbol in symbols { - self.insert(symbol, kind); - } - } - - pub fn contains(&self, symbol: &str) -> bool { - self.symbols.contains_key(symbol) - } - - fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { - let Some(conflict) = self.conflicts.first() else { - return Ok(()); - }; - Err(conflicting_source_error(stage, "scalar", conflict)) - } -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum VerifierPointSourceKind { - OpeningInput, - SumcheckInstance, - PointZero, - PointSlice, - PointConcat, -} - -#[derive(Clone, Debug, Default, PartialEq, Eq)] -pub struct VerifierPointSourceSet { - symbols: BTreeMap, - conflicts: Vec>, -} - -impl VerifierPointSourceSet { - pub fn insert(&mut self, symbol: &str, kind: VerifierPointSourceKind) { - match self.symbols.entry(symbol.to_owned()) { - std::collections::btree_map::Entry::Vacant(entry) => { - let _entry = entry.insert(kind); - } - std::collections::btree_map::Entry::Occupied(entry) => { - let existing = *entry.get(); - if existing != kind { - self.conflicts.push(VerifierSourceConflict { - symbol: symbol.to_owned(), - existing, - incoming: kind, - }); - } - } - } - } - - pub fn extend<'a>( - &mut self, - symbols: impl IntoIterator, - kind: VerifierPointSourceKind, - ) { - for symbol in symbols { - self.insert(symbol, kind); - } - } - - pub fn contains(&self, symbol: &str) -> bool { - self.symbols.contains_key(symbol) - } - - fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { - let Some(conflict) = self.conflicts.first() else { - return Ok(()); - }; - Err(conflicting_source_error(stage, "point", conflict)) - } -} - -#[derive(Clone, Debug, PartialEq, Eq)] -struct VerifierSourceConflict { - symbol: String, - existing: K, - incoming: K, -} - -fn conflicting_source_error( - stage: &str, - value_kind: &str, - conflict: &VerifierSourceConflict, -) -> EmitError -where - K: std::fmt::Debug, -{ - EmitError::new(format!( - "{stage} {value_kind} source @{} has conflicting kinds {:?} and {:?}", - conflict.symbol, conflict.existing, conflict.incoming - )) -} - pub fn resolve_output_claims( stage: &str, output_values: &[StructuredPolynomialEvalPlan], @@ -1337,6 +1200,10 @@ mod tests { use std::collections::BTreeSet; use crate::emit::rust::EmitError; + use crate::protocols::jolt::verifier_values::{ + VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarSourceKind, + VerifierScalarSourceSet, + }; use super::{ resolve_output_claims, verify_output_claims, FieldExprDependencies, @@ -1344,8 +1211,7 @@ mod tests { SumcheckOutputEvalFamilyPlan, SumcheckOutputEvalFamilySharedTermPlan, SumcheckOutputFunctionFamilyPlan, SumcheckOutputFunctionFamilyTermPlan, SumcheckOutputFunctionKind, SumcheckOutputProductFamilyPlan, - SumcheckOutputProductFamilyTermPlan, VerifierPointSourceKind, VerifierPointSourceSet, - VerifierScalarSourceKind, VerifierScalarSourceSet, + SumcheckOutputProductFamilyTermPlan, }; struct TestFieldExpr { diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs new file mode 100644 index 0000000000..887781c1f4 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -0,0 +1,141 @@ +use std::collections::BTreeMap; + +use crate::emit::rust::EmitError; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum VerifierScalarSourceKind { + OpeningInput, + FieldConstant, + TranscriptScalar, + FieldExpr, + PointDerived, + SumcheckEval, + StructuredPolynomialEval, + OutputEvalFamily, + OutputProductFamily, + OutputFunctionFamily, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct VerifierScalarSourceSet { + symbols: BTreeMap, + conflicts: Vec>, +} + +impl VerifierScalarSourceSet { + pub fn insert(&mut self, symbol: &str, kind: VerifierScalarSourceKind) { + match self.symbols.entry(symbol.to_owned()) { + std::collections::btree_map::Entry::Vacant(entry) => { + let _entry = entry.insert(kind); + } + std::collections::btree_map::Entry::Occupied(entry) => { + let existing = *entry.get(); + if existing != kind { + self.conflicts.push(VerifierSourceConflict { + symbol: symbol.to_owned(), + existing, + incoming: kind, + }); + } + } + } + } + + pub fn extend<'a>( + &mut self, + symbols: impl IntoIterator, + kind: VerifierScalarSourceKind, + ) { + for symbol in symbols { + self.insert(symbol, kind); + } + } + + pub fn contains(&self, symbol: &str) -> bool { + self.symbols.contains_key(symbol) + } + + pub(crate) fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { + let Some(conflict) = self.conflicts.first() else { + return Ok(()); + }; + Err(conflicting_source_error(stage, "scalar", conflict)) + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum VerifierPointSourceKind { + OpeningInput, + SumcheckInstance, + PointZero, + PointSlice, + PointConcat, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct VerifierPointSourceSet { + symbols: BTreeMap, + conflicts: Vec>, +} + +impl VerifierPointSourceSet { + pub fn insert(&mut self, symbol: &str, kind: VerifierPointSourceKind) { + match self.symbols.entry(symbol.to_owned()) { + std::collections::btree_map::Entry::Vacant(entry) => { + let _entry = entry.insert(kind); + } + std::collections::btree_map::Entry::Occupied(entry) => { + let existing = *entry.get(); + if existing != kind { + self.conflicts.push(VerifierSourceConflict { + symbol: symbol.to_owned(), + existing, + incoming: kind, + }); + } + } + } + } + + pub fn extend<'a>( + &mut self, + symbols: impl IntoIterator, + kind: VerifierPointSourceKind, + ) { + for symbol in symbols { + self.insert(symbol, kind); + } + } + + pub fn contains(&self, symbol: &str) -> bool { + self.symbols.contains_key(symbol) + } + + pub(crate) fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { + let Some(conflict) = self.conflicts.first() else { + return Ok(()); + }; + Err(conflicting_source_error(stage, "point", conflict)) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct VerifierSourceConflict { + symbol: String, + existing: K, + incoming: K, +} + +fn conflicting_source_error( + stage: &str, + value_kind: &str, + conflict: &VerifierSourceConflict, +) -> EmitError +where + K: std::fmt::Debug, +{ + EmitError::new(format!( + "{stage} {value_kind} source @{} has conflicting kinds {:?} and {:?}", + conflict.symbol, conflict.existing, conflict.incoming + )) +} From ab9ecdabfc1c26b6a8a8ecd708f2a7a7a86ab80a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 13:58:02 -0600 Subject: [PATCH 089/171] refactor(bolt): derive value sources from plan Extend VerifierStagePlan with scalar and point source inputs and use plan-derived value sources for Stage 3-7 output-claim validation. Remove dead per-stage point source builders while leaving relation execution unchanged. --- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 8 +- .../src/protocols/jolt/emit/rust/stage3.rs | 30 +- .../src/protocols/jolt/emit/rust/stage4.rs | 30 +- .../src/protocols/jolt/emit/rust/stage5.rs | 33 +-- .../src/protocols/jolt/emit/rust/stage6.rs | 37 +-- .../src/protocols/jolt/emit/rust/stage7.rs | 37 +-- .../bolt/src/protocols/jolt/verifier_plan.rs | 259 ++++++++++++++++++ 7 files changed, 298 insertions(+), 136 deletions(-) diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index ef2fa85cf7..4800d48e51 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -581,9 +581,11 @@ eval-family values. The scalar/point source registry has been moved out of `verifier_output_claims` into `verifier_values`. This is only the foundation: -it gives scalar and point domains an explicit home, but field-vector values, -eval-family values, and relation-output execution are not yet lowered through a -single typed graph. +it gives scalar and point domains an explicit home. `VerifierStagePlan` now +carries enough scalar/point source data for Stage 3-7 output-claim validation +to consume plan-derived value sources instead of rebuilding point sources in +each stage. Field-vector values, eval-family values, and relation-output +execution are not yet lowered through a single typed graph. ### Dialect changes diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index a2e6b04c9c..114d8c96be 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -228,11 +228,13 @@ verifier_plan::impl_verifier_plan_source_traits!( step = Stage3ProgramStepPlan, squeeze = Stage3TranscriptSqueezePlan, opening_input = Stage3OpeningInputPlan, + field_constant = Stage3FieldConstantPlan, field_expr = Stage3FieldExprPlan, claim = Stage3SumcheckClaimPlan, batch = Stage3SumcheckBatchPlan, driver = Stage3SumcheckDriverPlan, instance = Stage3SumcheckInstanceResultPlan, + eval = Stage3SumcheckEvalPlan, point_slice = Stage3PointSlicePlan, point_concat = Stage3PointConcatPlan, opening_claim = Stage3OpeningClaimPlan, @@ -737,29 +739,6 @@ impl Stage3CpuProgram { values } - fn point_value_symbols(&self) -> verifier_values::VerifierPointSourceSet { - let mut values = verifier_values::VerifierPointSourceSet::default(); - values.extend( - self.opening_inputs.iter().map(|input| &input.symbol), - verifier_values::VerifierPointSourceKind::OpeningInput, - ); - values.extend( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - verifier_values::VerifierPointSourceKind::SumcheckInstance, - ); - values.extend( - self.point_slices.iter().map(|slice| &slice.symbol), - verifier_values::VerifierPointSourceKind::PointSlice, - ); - values.extend( - self.point_concats.iter().map(|concat| &concat.symbol), - verifier_values::VerifierPointSourceKind::PointConcat, - ); - values - } - fn verify_kernel_definitions(&self) -> Result<(), EmitError> { for kernel in &self.kernels { if kernel.backend != "cpu" { @@ -939,8 +918,9 @@ impl Stage3CpuProgram { .iter() .map(|instance| &instance.relation), ); - let field_values = self.field_value_symbols(); - let point_values = self.point_value_symbols(); + let plan = self.verifier_plan()?; + let field_values = plan.scalar_value_sources(); + let point_values = plan.point_value_sources(); verifier_output_claims::verify_output_claims( "stage3", verifier_output_claims::OutputClaimVerification { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 701e392907..7e8bda3a43 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -241,11 +241,13 @@ verifier_plan::impl_verifier_plan_source_traits!( step = Stage4ProgramStepPlan, squeeze = Stage4TranscriptSqueezePlan, opening_input = Stage4OpeningInputPlan, + field_constant = Stage4FieldConstantPlan, field_expr = Stage4FieldExprPlan, claim = Stage4SumcheckClaimPlan, batch = Stage4SumcheckBatchPlan, driver = Stage4SumcheckDriverPlan, instance = Stage4SumcheckInstanceResultPlan, + eval = Stage4SumcheckEvalPlan, point_slice = Stage4PointSlicePlan, point_concat = Stage4PointConcatPlan, opening_claim = Stage4OpeningClaimPlan, @@ -758,29 +760,6 @@ impl Stage4CpuProgram { values } - fn point_value_symbols(&self) -> verifier_values::VerifierPointSourceSet { - let mut values = verifier_values::VerifierPointSourceSet::default(); - values.extend( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - verifier_values::VerifierPointSourceKind::SumcheckInstance, - ); - values.extend( - self.opening_inputs.iter().map(|input| &input.symbol), - verifier_values::VerifierPointSourceKind::OpeningInput, - ); - values.extend( - self.point_slices.iter().map(|slice| &slice.symbol), - verifier_values::VerifierPointSourceKind::PointSlice, - ); - values.extend( - self.point_concats.iter().map(|concat| &concat.symbol), - verifier_values::VerifierPointSourceKind::PointConcat, - ); - values - } - fn verify_kernel_definitions(&self) -> Result<(), EmitError> { for kernel in &self.kernels { if kernel.backend != "cpu" { @@ -959,8 +938,9 @@ impl Stage4CpuProgram { .iter() .map(|instance| &instance.relation), ); - let field_values = self.field_value_symbols(); - let point_values = self.point_value_symbols(); + let plan = self.verifier_plan()?; + let field_values = plan.scalar_value_sources(); + let point_values = plan.point_value_sources(); verifier_output_claims::verify_output_claims( "stage4", verifier_output_claims::OutputClaimVerification { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 61543a6fe0..4157547814 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -263,11 +263,13 @@ verifier_plan::impl_verifier_plan_source_traits!( step = Stage5ProgramStepPlan, squeeze = Stage5TranscriptSqueezePlan, opening_input = Stage5OpeningInputPlan, + field_constant = Stage5FieldConstantPlan, field_expr = Stage5FieldExprPlan, claim = Stage5SumcheckClaimPlan, batch = Stage5SumcheckBatchPlan, driver = Stage5SumcheckDriverPlan, instance = Stage5SumcheckInstanceResultPlan, + eval = Stage5SumcheckEvalPlan, point_slice = Stage5PointSlicePlan, point_concat = Stage5PointConcatPlan, opening_claim = Stage5OpeningClaimPlan, @@ -275,6 +277,9 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_batch = Stage5OpeningBatchPlan, absorb = Stage5TranscriptAbsorbBytesPlan, indexed_eval_families = indexed_eval_families, + output_families = output_families, + output_product_families = output_product_families, + output_function_families = output_function_families, ); pub fn stage5_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -854,29 +859,6 @@ impl Stage5CpuProgram { values } - fn point_value_symbols(&self) -> verifier_values::VerifierPointSourceSet { - let mut values = verifier_values::VerifierPointSourceSet::default(); - values.extend( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - verifier_values::VerifierPointSourceKind::SumcheckInstance, - ); - values.extend( - self.opening_inputs.iter().map(|input| &input.symbol), - verifier_values::VerifierPointSourceKind::OpeningInput, - ); - values.extend( - self.point_slices.iter().map(|slice| &slice.symbol), - verifier_values::VerifierPointSourceKind::PointSlice, - ); - values.extend( - self.point_concats.iter().map(|concat| &concat.symbol), - verifier_values::VerifierPointSourceKind::PointConcat, - ); - values - } - fn verify_kernel_definitions(&self) -> Result<(), EmitError> { for kernel in &self.kernels { if kernel.backend != "cpu" { @@ -1056,8 +1038,9 @@ impl Stage5CpuProgram { .iter() .map(|instance| &instance.relation), ); - let field_values = self.field_value_symbols(); - let point_values = self.point_value_symbols(); + let plan = self.verifier_plan()?; + let field_values = plan.scalar_value_sources(); + let point_values = plan.point_value_sources(); verifier_output_claims::verify_output_claims( "stage5", verifier_output_claims::OutputClaimVerification { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 6232fe79c9..e85d8adb89 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -289,11 +289,13 @@ verifier_plan::impl_verifier_plan_source_traits!( step = Stage6ProgramStepPlan, squeeze = Stage6TranscriptSqueezePlan, opening_input = Stage6OpeningInputPlan, + field_constant = Stage6FieldConstantPlan, field_expr = Stage6FieldExprPlan, claim = Stage6SumcheckClaimPlan, batch = Stage6SumcheckBatchPlan, driver = Stage6SumcheckDriverPlan, instance = Stage6SumcheckInstanceResultPlan, + eval = Stage6SumcheckEvalPlan, point_slice = Stage6PointSlicePlan, point_concat = Stage6PointConcatPlan, opening_claim = Stage6OpeningClaimPlan, @@ -302,6 +304,9 @@ verifier_plan::impl_verifier_plan_source_traits!( absorb = Stage6TranscriptAbsorbBytesPlan, point_zero = Stage6PointZeroPlan, indexed_eval_families = indexed_eval_families, + output_families = output_families, + output_product_families = output_product_families, + output_function_families = output_function_families, ); pub fn stage6_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -889,33 +894,6 @@ impl Stage6CpuProgram { values } - fn point_value_symbols(&self) -> verifier_values::VerifierPointSourceSet { - let mut values = verifier_values::VerifierPointSourceSet::default(); - values.extend( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - verifier_values::VerifierPointSourceKind::SumcheckInstance, - ); - values.extend( - self.opening_inputs.iter().map(|input| &input.symbol), - verifier_values::VerifierPointSourceKind::OpeningInput, - ); - values.extend( - self.point_zeros.iter().map(|zero| &zero.symbol), - verifier_values::VerifierPointSourceKind::PointZero, - ); - values.extend( - self.point_slices.iter().map(|slice| &slice.symbol), - verifier_values::VerifierPointSourceKind::PointSlice, - ); - values.extend( - self.point_concats.iter().map(|concat| &concat.symbol), - verifier_values::VerifierPointSourceKind::PointConcat, - ); - values - } - fn verify_kernel_definitions(&self) -> Result<(), EmitError> { for kernel in &self.kernels { if kernel.backend != "cpu" { @@ -1089,8 +1067,9 @@ impl Stage6CpuProgram { .iter() .map(|instance| &instance.relation), ); - let field_values = self.field_value_symbols(); - let point_values = self.point_value_symbols(); + let plan = self.verifier_plan()?; + let field_values = plan.scalar_value_sources(); + let point_values = plan.point_value_sources(); verifier_output_claims::verify_output_claims( "stage6", verifier_output_claims::OutputClaimVerification { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index d15b63d42f..da07bfb937 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -269,11 +269,13 @@ verifier_plan::impl_verifier_plan_source_traits!( step = Stage7ProgramStepPlan, squeeze = Stage7TranscriptSqueezePlan, opening_input = Stage7OpeningInputPlan, + field_constant = Stage7FieldConstantPlan, field_expr = Stage7FieldExprPlan, claim = Stage7SumcheckClaimPlan, batch = Stage7SumcheckBatchPlan, driver = Stage7SumcheckDriverPlan, instance = Stage7SumcheckInstanceResultPlan, + eval = Stage7SumcheckEvalPlan, point_slice = Stage7PointSlicePlan, point_concat = Stage7PointConcatPlan, opening_claim = Stage7OpeningClaimPlan, @@ -281,6 +283,9 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_batch = Stage7OpeningBatchPlan, absorb = Stage7TranscriptAbsorbBytesPlan, point_zero = Stage7PointZeroPlan, + output_families = output_families, + output_product_families = output_product_families, + output_function_families = output_function_families, ); pub fn stage7_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -827,33 +832,6 @@ impl Stage7CpuProgram { values } - fn point_value_symbols(&self) -> verifier_values::VerifierPointSourceSet { - let mut values = verifier_values::VerifierPointSourceSet::default(); - values.extend( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - verifier_values::VerifierPointSourceKind::SumcheckInstance, - ); - values.extend( - self.opening_inputs.iter().map(|input| &input.symbol), - verifier_values::VerifierPointSourceKind::OpeningInput, - ); - values.extend( - self.point_zeros.iter().map(|zero| &zero.symbol), - verifier_values::VerifierPointSourceKind::PointZero, - ); - values.extend( - self.point_slices.iter().map(|slice| &slice.symbol), - verifier_values::VerifierPointSourceKind::PointSlice, - ); - values.extend( - self.point_concats.iter().map(|concat| &concat.symbol), - verifier_values::VerifierPointSourceKind::PointConcat, - ); - values - } - fn verify_kernel_definitions(&self) -> Result<(), EmitError> { for kernel in &self.kernels { if kernel.backend != "cpu" { @@ -1027,8 +1005,9 @@ impl Stage7CpuProgram { .iter() .map(|instance| &instance.relation), ); - let field_values = self.field_value_symbols(); - let point_values = self.point_value_symbols(); + let plan = self.verifier_plan()?; + let field_values = plan.scalar_value_sources(); + let point_values = plan.point_value_sources(); verifier_output_claims::verify_output_claims( "stage7", verifier_output_claims::OutputClaimVerification { diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index bbc46da458..91a032989f 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -6,6 +6,14 @@ use crate::protocols::jolt::rust_target_plan::{ RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, }; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; +use crate::protocols::jolt::verifier_output_claims::{ + StructuredPolynomialEvalPlan, SumcheckOutputClaimPlan, SumcheckOutputEvalFamilyPlan, + SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan, +}; +use crate::protocols::jolt::verifier_values::{ + VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarSourceKind, + VerifierScalarSourceSet, +}; #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierProgramStepPlan { @@ -96,6 +104,13 @@ impl VerifierOpeningInputPlan { } } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierFieldConstantPlan { + pub(crate) symbol: String, + pub(crate) field: String, + pub(crate) value: usize, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierFieldExprPlan { pub(crate) symbol: String, @@ -117,6 +132,15 @@ impl VerifierFieldExprPlan { } } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierSumcheckEvalPlan { + pub(crate) symbol: String, + pub(crate) source: String, + pub(crate) name: String, + pub(crate) index: usize, + pub(crate) oracle: String, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierSumcheckClaimPlan { pub(crate) symbol: String, @@ -231,12 +255,19 @@ pub(crate) struct VerifierStagePlan { pub(crate) transcript_squeezes: Vec, pub(crate) transcript_absorb_bytes: Vec, pub(crate) opening_inputs: Vec, + pub(crate) field_constants: Vec, pub(crate) field_exprs: Vec, pub(crate) claims: Vec, pub(crate) batches: Vec, pub(crate) drivers: Vec, pub(crate) instance_results: Vec, + pub(crate) sumcheck_evals: Vec, pub(crate) indexed_eval_families: Vec, + pub(crate) output_values: Vec, + pub(crate) output_families: Vec, + pub(crate) output_product_families: Vec, + pub(crate) output_function_families: Vec, + pub(crate) output_claims: Vec, pub(crate) point_zeros: Vec, pub(crate) point_slices: Vec, pub(crate) point_concats: Vec, @@ -245,6 +276,118 @@ pub(crate) struct VerifierStagePlan { pub(crate) opening_batches: Vec, } +impl VerifierStagePlan { + pub(crate) fn scalar_value_sources(&self) -> VerifierScalarSourceSet { + let mut values = VerifierScalarSourceSet::default(); + values.extend( + self.opening_inputs.iter().map(|input| &input.symbol), + VerifierScalarSourceKind::OpeningInput, + ); + values.extend( + self.field_constants.iter().map(|constant| &constant.symbol), + VerifierScalarSourceKind::FieldConstant, + ); + values.extend( + self.transcript_squeezes + .iter() + .filter(|squeeze| { + matches!( + squeeze.kind, + TranscriptSqueezeKind::ChallengeScalar | TranscriptSqueezeKind::Scalar + ) + }) + .map(|squeeze| &squeeze.symbol), + VerifierScalarSourceKind::TranscriptScalar, + ); + values.extend( + self.output_values.iter().map(|value| &value.symbol), + VerifierScalarSourceKind::StructuredPolynomialEval, + ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), + VerifierScalarSourceKind::StructuredPolynomialEval, + ); + values.extend( + self.output_families.iter().map(|family| &family.symbol), + VerifierScalarSourceKind::OutputEvalFamily, + ); + values.extend( + self.output_product_families + .iter() + .map(|family| &family.symbol), + VerifierScalarSourceKind::OutputProductFamily, + ); + values.extend( + self.output_function_families + .iter() + .map(|family| &family.symbol), + VerifierScalarSourceKind::OutputFunctionFamily, + ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), + VerifierScalarSourceKind::OutputEvalFamily, + ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), + VerifierScalarSourceKind::OutputProductFamily, + ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), + VerifierScalarSourceKind::OutputFunctionFamily, + ); + values.extend( + self.field_exprs.iter().map(|expr| &expr.symbol), + VerifierScalarSourceKind::FieldExpr, + ); + values.extend( + self.output_claims + .iter() + .flat_map(|claim| claim.local_scalars.iter()), + VerifierScalarSourceKind::PointDerived, + ); + values.extend( + self.sumcheck_evals.iter().map(|eval| &eval.symbol), + VerifierScalarSourceKind::SumcheckEval, + ); + values + } + + pub(crate) fn point_value_sources(&self) -> VerifierPointSourceSet { + let mut values = VerifierPointSourceSet::default(); + values.extend( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + VerifierPointSourceKind::SumcheckInstance, + ); + values.extend( + self.opening_inputs.iter().map(|input| &input.symbol), + VerifierPointSourceKind::OpeningInput, + ); + values.extend( + self.point_zeros.iter().map(|zero| &zero.symbol), + VerifierPointSourceKind::PointZero, + ); + values.extend( + self.point_slices.iter().map(|slice| &slice.symbol), + VerifierPointSourceKind::PointSlice, + ); + values.extend( + self.point_concats.iter().map(|concat| &concat.symbol), + VerifierPointSourceKind::PointConcat, + ); + values + } +} + pub(crate) trait VerifierProgramStepSource { fn kind(&self) -> &str; fn symbol(&self) -> &str; @@ -273,12 +416,26 @@ pub(crate) trait VerifierOpeningInputSource { fn claim_kind(&self) -> &str; } +pub(crate) trait VerifierFieldConstantSource { + fn symbol(&self) -> &str; + fn field(&self) -> &str; + fn value(&self) -> usize; +} + pub(crate) trait VerifierFieldExprSource { fn symbol(&self) -> &str; fn formula(&self) -> &str; fn operands(&self) -> &[String]; } +pub(crate) trait VerifierSumcheckEvalSource { + fn symbol(&self) -> &str; + fn source(&self) -> &str; + fn name(&self) -> &str; + fn index(&self) -> usize; + fn oracle(&self) -> &str; +} + pub(crate) trait VerifierSumcheckClaimSource { fn symbol(&self) -> &str; fn stage(&self) -> &str; @@ -381,11 +538,13 @@ pub(crate) trait VerifierStagePlanSource { type Step: VerifierProgramStepSource; type Squeeze: VerifierTranscriptSqueezeSource; type OpeningInput: VerifierOpeningInputSource; + type FieldConstant: VerifierFieldConstantSource; type FieldExpr: VerifierFieldExprSource; type Claim: VerifierSumcheckClaimSource; type Batch: VerifierSumcheckBatchSource; type Driver: VerifierSumcheckDriverSource; type Instance: VerifierSumcheckInstanceResultSource; + type Eval: VerifierSumcheckEvalSource; type PointSlice: VerifierPointSliceSource; type PointConcat: VerifierPointConcatSource; type OpeningClaim: VerifierOpeningClaimSource; @@ -396,12 +555,25 @@ pub(crate) trait VerifierStagePlanSource { fn transcript_squeezes(&self) -> &[Self::Squeeze]; fn transcript_absorb_bytes(&self) -> Vec; fn opening_inputs(&self) -> &[Self::OpeningInput]; + fn field_constants(&self) -> &[Self::FieldConstant]; fn field_exprs(&self) -> &[Self::FieldExpr]; fn claims(&self) -> &[Self::Claim]; fn batches(&self) -> &[Self::Batch]; fn drivers(&self) -> &[Self::Driver]; fn instance_results(&self) -> &[Self::Instance]; + fn sumcheck_evals(&self) -> &[Self::Eval]; fn indexed_eval_families(&self) -> &[IndexedEvalFamilyPlan]; + fn output_values(&self) -> &[StructuredPolynomialEvalPlan]; + fn output_families(&self) -> &[SumcheckOutputEvalFamilyPlan] { + &[] + } + fn output_product_families(&self) -> &[SumcheckOutputProductFamilyPlan] { + &[] + } + fn output_function_families(&self) -> &[SumcheckOutputFunctionFamilyPlan] { + &[] + } + fn output_claims(&self) -> &[SumcheckOutputClaimPlan]; fn point_zeros(&self) -> Vec; fn point_slices(&self) -> &[Self::PointSlice]; fn point_concats(&self) -> &[Self::PointConcat]; @@ -450,6 +622,15 @@ where ) }) .collect::, EmitError>>()?, + field_constants: source + .field_constants() + .iter() + .map(|constant| VerifierFieldConstantPlan { + symbol: constant.symbol().to_owned(), + field: constant.field().to_owned(), + value: constant.value(), + }) + .collect(), field_exprs: source .field_exprs() .iter() @@ -533,7 +714,23 @@ where }) }) .collect::, EmitError>>()?, + sumcheck_evals: source + .sumcheck_evals() + .iter() + .map(|eval| VerifierSumcheckEvalPlan { + symbol: eval.symbol().to_owned(), + source: eval.source().to_owned(), + name: eval.name().to_owned(), + index: eval.index(), + oracle: eval.oracle().to_owned(), + }) + .collect(), indexed_eval_families: source.indexed_eval_families().to_vec(), + output_values: source.output_values().to_vec(), + output_families: source.output_families().to_vec(), + output_product_families: source.output_product_families().to_vec(), + output_function_families: source.output_function_families().to_vec(), + output_claims: source.output_claims().to_vec(), point_zeros: source.point_zeros(), point_slices: source .point_slices() @@ -633,11 +830,13 @@ macro_rules! impl_verifier_plan_source_traits { step = $step:ty, squeeze = $squeeze:ty, opening_input = $opening_input:ty, + field_constant = $field_constant:ty, field_expr = $field_expr:ty, claim = $claim:ty, batch = $batch:ty, driver = $driver:ty, instance = $instance:ty, + eval = $eval:ty, point_slice = $point_slice:ty, point_concat = $point_concat:ty, opening_claim = $opening_claim:ty, @@ -646,17 +845,22 @@ macro_rules! impl_verifier_plan_source_traits { $(, absorb = $absorb:ty)? $(, point_zero = $point_zero:ty)? $(, indexed_eval_families = $indexed_eval_families:ident)? + $(, output_families = $output_families:ident)? + $(, output_product_families = $output_product_families:ident)? + $(, output_function_families = $output_function_families:ident)? $(,)? ) => { impl $crate::protocols::jolt::verifier_plan::VerifierStagePlanSource for $program { type Step = $step; type Squeeze = $squeeze; type OpeningInput = $opening_input; + type FieldConstant = $field_constant; type FieldExpr = $field_expr; type Claim = $claim; type Batch = $batch; type Driver = $driver; type Instance = $instance; + type Eval = $eval; type PointSlice = $point_slice; type PointConcat = $point_concat; type OpeningClaim = $opening_claim; @@ -671,16 +875,39 @@ macro_rules! impl_verifier_plan_source_traits { ) } fn opening_inputs(&self) -> &[Self::OpeningInput] { &self.opening_inputs } + fn field_constants(&self) -> &[Self::FieldConstant] { &self.field_constants } fn field_exprs(&self) -> &[Self::FieldExpr] { &self.field_exprs } fn claims(&self) -> &[Self::Claim] { &self.claims } fn batches(&self) -> &[Self::Batch] { &self.batches } fn drivers(&self) -> &[Self::Driver] { &self.drivers } fn instance_results(&self) -> &[Self::Instance] { &self.instance_results } + fn sumcheck_evals(&self) -> &[Self::Eval] { &self.evals } fn indexed_eval_families(&self) -> &[$crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan] { $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( @indexed_eval_families self $(, $indexed_eval_families)? ) } + fn output_values(&self) -> &[$crate::protocols::jolt::verifier_output_claims::StructuredPolynomialEvalPlan] { + &self.output_values + } + fn output_families(&self) -> &[$crate::protocols::jolt::verifier_output_claims::SumcheckOutputEvalFamilyPlan] { + $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( + @output_families self $(, $output_families)? + ) + } + fn output_product_families(&self) -> &[$crate::protocols::jolt::verifier_output_claims::SumcheckOutputProductFamilyPlan] { + $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( + @output_product_families self $(, $output_product_families)? + ) + } + fn output_function_families(&self) -> &[$crate::protocols::jolt::verifier_output_claims::SumcheckOutputFunctionFamilyPlan] { + $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( + @output_function_families self $(, $output_function_families)? + ) + } + fn output_claims(&self) -> &[$crate::protocols::jolt::verifier_output_claims::SumcheckOutputClaimPlan] { + &self.output_claims + } fn point_zeros(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierPointZeroPlan> { $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( @point_zeros self $(, $point_zero)? @@ -723,12 +950,26 @@ macro_rules! impl_verifier_plan_source_traits { fn claim_kind(&self) -> &str { &self.claim_kind } } + impl $crate::protocols::jolt::verifier_plan::VerifierFieldConstantSource for $field_constant { + fn symbol(&self) -> &str { &self.symbol } + fn field(&self) -> &str { &self.field } + fn value(&self) -> usize { self.value } + } + impl $crate::protocols::jolt::verifier_plan::VerifierFieldExprSource for $field_expr { fn symbol(&self) -> &str { &self.symbol } fn formula(&self) -> &str { &self.formula } fn operands(&self) -> &[String] { &self.operands } } + impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckEvalSource for $eval { + fn symbol(&self) -> &str { &self.symbol } + fn source(&self) -> &str { &self.source } + fn name(&self) -> &str { &self.name } + fn index(&self) -> usize { self.index } + fn oracle(&self) -> &str { &self.oracle } + } + impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckClaimSource for $claim { fn symbol(&self) -> &str { &self.symbol } fn stage(&self) -> &str { &self.stage } @@ -849,6 +1090,24 @@ macro_rules! impl_verifier_plan_source_traits { (@indexed_eval_families $self:ident) => { &[] }; + (@output_families $self:ident, $output_families:ident) => { + &$self.$output_families + }; + (@output_families $self:ident) => { + &[] + }; + (@output_product_families $self:ident, $output_product_families:ident) => { + &$self.$output_product_families + }; + (@output_product_families $self:ident) => { + &[] + }; + (@output_function_families $self:ident, $output_function_families:ident) => { + &$self.$output_function_families + }; + (@output_function_families $self:ident) => { + &[] + }; } pub(crate) use impl_verifier_plan_source_traits; From df5b1e0e55bfb5e6cd68afb3d3fa3f8eb5c304d6 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 14:54:42 -0600 Subject: [PATCH 090/171] refactor(bolt): plan opening flow sources --- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 7 ++-- .../src/protocols/jolt/emit/rust/stage3.rs | 37 +++++++++++------- .../src/protocols/jolt/emit/rust/stage4.rs | 37 +++++++++++------- .../src/protocols/jolt/emit/rust/stage5.rs | 37 +++++++++++------- .../src/protocols/jolt/emit/rust/stage6.rs | 39 ++++++++++++------- .../src/protocols/jolt/emit/rust/stage7.rs | 39 ++++++++++++------- .../bolt/src/protocols/jolt/verifier_plan.rs | 20 ++++++++++ 7 files changed, 141 insertions(+), 75 deletions(-) diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 4800d48e51..1f93709bb2 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -583,9 +583,10 @@ The scalar/point source registry has been moved out of `verifier_output_claims` into `verifier_values`. This is only the foundation: it gives scalar and point domains an explicit home. `VerifierStagePlan` now carries enough scalar/point source data for Stage 3-7 output-claim validation -to consume plan-derived value sources instead of rebuilding point sources in -each stage. Field-vector values, eval-family values, and relation-output -execution are not yet lowered through a single typed graph. +and verifier opening-flow validation to consume plan-derived value sources +instead of rebuilding point sources in each stage. Field-vector values, +eval-family values, and relation-output execution are not yet lowered through a +single typed graph. ### Dialect changes diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 114d8c96be..11b6a8f18e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -937,19 +937,24 @@ impl Stage3CpuProgram { } fn verify_opening_flow(&self) -> Result<(), EmitError> { - let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); - point_sources.extend(symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - )); - point_sources.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_sources.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); + let point_sources = if self.role == Role::Verifier { + self.verifier_plan()?.opening_point_sources() + } else { + let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); + point_sources.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + point_sources.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_sources.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + point_sources + }; for slice in &self.point_slices { if !point_sources.contains(&slice.input) { return Err(EmitError::new(format!( @@ -968,7 +973,11 @@ impl Stage3CpuProgram { } } } - let eval_sources = self.field_value_symbols(); + let eval_sources = if self.role == Role::Verifier { + self.verifier_plan()?.scalar_value_sources() + } else { + self.field_value_symbols() + }; let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( self.opening_claims.iter().map(|claim| &claim.symbol), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 7e8bda3a43..d6b8afc093 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -957,19 +957,24 @@ impl Stage4CpuProgram { } fn verify_opening_flow(&self) -> Result<(), EmitError> { - let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); - point_sources.extend(symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - )); - point_sources.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_sources.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); + let point_sources = if self.role == Role::Verifier { + self.verifier_plan()?.opening_point_sources() + } else { + let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); + point_sources.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + point_sources.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_sources.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + point_sources + }; for slice in &self.point_slices { if !point_sources.contains(&slice.input) { return Err(EmitError::new(format!( @@ -988,7 +993,11 @@ impl Stage4CpuProgram { } } } - let eval_sources = self.field_value_symbols(); + let eval_sources = if self.role == Role::Verifier { + self.verifier_plan()?.scalar_value_sources() + } else { + self.field_value_symbols() + }; let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( self.opening_claims.iter().map(|claim| &claim.symbol), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 4157547814..36b905c101 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1057,19 +1057,24 @@ impl Stage5CpuProgram { } fn verify_opening_flow(&self) -> Result<(), EmitError> { - let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); - point_sources.extend(symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - )); - point_sources.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_sources.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); + let point_sources = if self.role == Role::Verifier { + self.verifier_plan()?.opening_point_sources() + } else { + let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); + point_sources.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + point_sources.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_sources.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + point_sources + }; for slice in &self.point_slices { if !point_sources.contains(&slice.input) { return Err(EmitError::new(format!( @@ -1088,7 +1093,11 @@ impl Stage5CpuProgram { } } } - let eval_sources = self.field_value_symbols(); + let eval_sources = if self.role == Role::Verifier { + self.verifier_plan()?.scalar_value_sources() + } else { + self.field_value_symbols() + }; let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( self.opening_claims.iter().map(|claim| &claim.symbol), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index e85d8adb89..313e0375e7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1086,20 +1086,25 @@ impl Stage6CpuProgram { } fn verify_opening_flow(&self) -> Result<(), EmitError> { - let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); - point_sources.extend(symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - )); - point_sources.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_sources.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); - point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_sources.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); + let point_sources = if self.role == Role::Verifier { + self.verifier_plan()?.opening_point_sources() + } else { + let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); + point_sources.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + point_sources.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_sources.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); + point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_sources.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + point_sources + }; for zero in &self.point_zeros { require_supported_symbol("point zero field", &zero.field, "bn254_fr")?; } @@ -1121,7 +1126,11 @@ impl Stage6CpuProgram { } } } - let eval_sources = self.field_value_symbols(); + let eval_sources = if self.role == Role::Verifier { + self.verifier_plan()?.scalar_value_sources() + } else { + self.field_value_symbols() + }; let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( self.opening_claims.iter().map(|claim| &claim.symbol), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index da07bfb937..ae9cdbc7fb 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1024,20 +1024,25 @@ impl Stage7CpuProgram { } fn verify_opening_flow(&self) -> Result<(), EmitError> { - let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); - point_sources.extend(symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - )); - point_sources.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_sources.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); - point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_sources.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); + let point_sources = if self.role == Role::Verifier { + self.verifier_plan()?.opening_point_sources() + } else { + let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); + point_sources.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + point_sources.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_sources.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); + point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_sources.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); + point_sources + }; for zero in &self.point_zeros { require_supported_symbol("point zero field", &zero.field, "bn254_fr")?; } @@ -1059,7 +1064,11 @@ impl Stage7CpuProgram { } } } - let eval_sources = self.field_value_symbols(); + let eval_sources = if self.role == Role::Verifier { + self.verifier_plan()?.scalar_value_sources() + } else { + self.field_value_symbols() + }; let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( self.opening_claims.iter().map(|claim| &claim.symbol), diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 91a032989f..48f0f5e85d 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -1,3 +1,4 @@ +use std::collections::BTreeSet; use std::fmt::Write as _; use crate::emit::rust::EmitError; @@ -386,6 +387,25 @@ impl VerifierStagePlan { ); values } + + pub(crate) fn opening_point_sources(&self) -> BTreeSet { + let mut values = BTreeSet::new(); + values.extend(self.drivers.iter().map(|driver| driver.symbol.clone())); + values.extend( + self.instance_results + .iter() + .map(|instance| instance.symbol.clone()), + ); + values.extend(self.opening_inputs.iter().map(|input| input.symbol.clone())); + values.extend(self.point_zeros.iter().map(|zero| zero.symbol.clone())); + values.extend(self.point_slices.iter().map(|slice| slice.symbol.clone())); + values.extend( + self.point_concats + .iter() + .map(|concat| concat.symbol.clone()), + ); + values + } } pub(crate) trait VerifierProgramStepSource { From 42aee61976646b79a693407ecd0245f4af344e92 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 15:01:08 -0600 Subject: [PATCH 091/171] refactor(bolt): split verifier field sources --- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 8 +++++--- crates/bolt/src/protocols/jolt/emit/rust/stage3.rs | 10 +++++++--- crates/bolt/src/protocols/jolt/emit/rust/stage4.rs | 10 +++++++--- crates/bolt/src/protocols/jolt/emit/rust/stage5.rs | 10 +++++++--- crates/bolt/src/protocols/jolt/emit/rust/stage6.rs | 10 +++++++--- crates/bolt/src/protocols/jolt/emit/rust/stage7.rs | 10 +++++++--- 6 files changed, 40 insertions(+), 18 deletions(-) diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 1f93709bb2..78e3e29f2d 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -584,9 +584,11 @@ The scalar/point source registry has been moved out of it gives scalar and point domains an explicit home. `VerifierStagePlan` now carries enough scalar/point source data for Stage 3-7 output-claim validation and verifier opening-flow validation to consume plan-derived value sources -instead of rebuilding point sources in each stage. Field-vector values, -eval-family values, and relation-output execution are not yet lowered through a -single typed graph. +instead of rebuilding point sources in each stage. Verifier field-flow +validation also consumes plan-derived scalar sources; the remaining CPU scalar +source builders are explicitly scoped to prover/role-neutral validation. +Field-vector values, eval-family values, and relation-output execution are not +yet lowered through a single typed graph. ### Dialect changes diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 11b6a8f18e..b4feca8306 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -679,7 +679,11 @@ impl Stage3CpuProgram { for constant in &self.field_constants { require_supported_symbol("field constant field", &constant.field, "bn254_fr")?; } - let field_values = self.field_value_symbols(); + let field_values = if self.role == Role::Verifier { + self.verifier_plan()?.scalar_value_sources() + } else { + self.cpu_field_value_sources() + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -707,7 +711,7 @@ impl Stage3CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> verifier_values::VerifierScalarSourceSet { + fn cpu_field_value_sources(&self) -> verifier_values::VerifierScalarSourceSet { let mut values = verifier_values::VerifierScalarSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), @@ -976,7 +980,7 @@ impl Stage3CpuProgram { let eval_sources = if self.role == Role::Verifier { self.verifier_plan()?.scalar_value_sources() } else { - self.field_value_symbols() + self.cpu_field_value_sources() }; let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index d6b8afc093..4586e56ec5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -700,7 +700,11 @@ impl Stage4CpuProgram { for constant in &self.field_constants { require_supported_symbol("field constant field", &constant.field, "bn254_fr")?; } - let field_values = self.field_value_symbols(); + let field_values = if self.role == Role::Verifier { + self.verifier_plan()?.scalar_value_sources() + } else { + self.cpu_field_value_sources() + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -728,7 +732,7 @@ impl Stage4CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> verifier_values::VerifierScalarSourceSet { + fn cpu_field_value_sources(&self) -> verifier_values::VerifierScalarSourceSet { let mut values = verifier_values::VerifierScalarSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), @@ -996,7 +1000,7 @@ impl Stage4CpuProgram { let eval_sources = if self.role == Role::Verifier { self.verifier_plan()?.scalar_value_sources() } else { - self.field_value_symbols() + self.cpu_field_value_sources() }; let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 36b905c101..b85d32da96 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -753,7 +753,11 @@ impl Stage5CpuProgram { for constant in &self.field_constants { require_supported_symbol("field constant field", &constant.field, "bn254_fr")?; } - let field_values = self.field_value_symbols(); + let field_values = if self.role == Role::Verifier { + self.verifier_plan()?.scalar_value_sources() + } else { + self.cpu_field_value_sources() + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -781,7 +785,7 @@ impl Stage5CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> verifier_values::VerifierScalarSourceSet { + fn cpu_field_value_sources(&self) -> verifier_values::VerifierScalarSourceSet { let mut values = verifier_values::VerifierScalarSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), @@ -1096,7 +1100,7 @@ impl Stage5CpuProgram { let eval_sources = if self.role == Role::Verifier { self.verifier_plan()?.scalar_value_sources() } else { - self.field_value_symbols() + self.cpu_field_value_sources() }; let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 313e0375e7..11c54321d9 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -788,7 +788,11 @@ impl Stage6CpuProgram { for constant in &self.field_constants { require_supported_symbol("field constant field", &constant.field, "bn254_fr")?; } - let field_values = self.field_value_symbols(); + let field_values = if self.role == Role::Verifier { + self.verifier_plan()?.scalar_value_sources() + } else { + self.cpu_field_value_sources() + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -816,7 +820,7 @@ impl Stage6CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> verifier_values::VerifierScalarSourceSet { + fn cpu_field_value_sources(&self) -> verifier_values::VerifierScalarSourceSet { let mut values = verifier_values::VerifierScalarSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), @@ -1129,7 +1133,7 @@ impl Stage6CpuProgram { let eval_sources = if self.role == Role::Verifier { self.verifier_plan()?.scalar_value_sources() } else { - self.field_value_symbols() + self.cpu_field_value_sources() }; let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index ae9cdbc7fb..80dca1395c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -756,7 +756,11 @@ impl Stage7CpuProgram { for constant in &self.field_constants { require_supported_symbol("field constant field", &constant.field, "bn254_fr")?; } - let field_values = self.field_value_symbols(); + let field_values = if self.role == Role::Verifier { + self.verifier_plan()?.scalar_value_sources() + } else { + self.cpu_field_value_sources() + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -784,7 +788,7 @@ impl Stage7CpuProgram { Ok(()) } - fn field_value_symbols(&self) -> verifier_values::VerifierScalarSourceSet { + fn cpu_field_value_sources(&self) -> verifier_values::VerifierScalarSourceSet { let mut values = verifier_values::VerifierScalarSourceSet::default(); values.extend( self.opening_inputs.iter().map(|input| &input.symbol), @@ -1067,7 +1071,7 @@ impl Stage7CpuProgram { let eval_sources = if self.role == Role::Verifier { self.verifier_plan()?.scalar_value_sources() } else { - self.field_value_symbols() + self.cpu_field_value_sources() }; let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( From 83ce594271734186fc4e94a8bb8aee8fd416f450 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 15:16:13 -0600 Subject: [PATCH 092/171] refactor(bolt): store eval families as vectors --- crates/bolt-verifier-runtime/src/lib.rs | 96 +++++++++++++++++++ crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 7 +- .../src/protocols/jolt/emit/rust/stage5.rs | 14 ++- .../src/protocols/jolt/emit/rust/stage6.rs | 14 ++- .../protocols/jolt/verifier_eval_families.rs | 59 +++++++++++- 5 files changed, 185 insertions(+), 5 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 857ec02bfe..6ff5176db7 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -825,6 +825,7 @@ impl SumcheckDriverInfo for SumcheckDriverPlan { pub struct ValueStore { scalars: Vec<(&'static str, F)>, points: Vec<(&'static str, Vec)>, + field_vectors: Vec<(&'static str, Vec)>, } impl ValueStore { @@ -1002,6 +1003,27 @@ impl ValueStore { } } + pub fn evaluate_named_eval_families( + &mut self, + families: &[NamedEvalFamilyPlan], + ) -> Result<(), RuntimePlanError> { + for family in families { + if self.try_field_vector(family.symbol).is_some() { + continue; + } + let values = family + .evals + .iter() + .map(|eval| { + self.try_scalar(eval) + .ok_or(RuntimePlanError::MissingValue { symbol: eval }) + }) + .collect::, RuntimePlanError>>()?; + self.insert_field_vector(family.symbol, values); + } + Ok(()) + } + pub fn verify_opening_equalities( &self, opening_equalities: &[OpeningClaimEqualityPlan], @@ -1043,6 +1065,18 @@ impl ValueStore { } } + pub fn insert_field_vector(&mut self, symbol: &'static str, values: Vec) { + if let Some((_, existing)) = self + .field_vectors + .iter_mut() + .find(|(name, _)| *name == symbol) + { + *existing = values; + } else { + self.field_vectors.push((symbol, values)); + } + } + pub fn scalar_or( &self, symbol: &'static str, @@ -1073,6 +1107,22 @@ impl ValueStore { .map(|(_, point)| point.as_slice()) } + pub fn field_vector_or( + &self, + symbol: &'static str, + missing_value: impl FnOnce(&'static str) -> E, + ) -> Result<&[F], E> { + self.try_field_vector(symbol) + .ok_or_else(|| missing_value(symbol)) + } + + pub fn try_field_vector(&self, symbol: &str) -> Option<&[F]> { + self.field_vectors + .iter() + .find(|(name, _)| *name == symbol) + .map(|(_, values)| values.as_slice()) + } + fn try_expr_operands(&self, expr: &FieldExprPlan) -> Option> { expr.operands .iter() @@ -1792,3 +1842,49 @@ pub fn pow_field(base: F, mut exponent: usize) -> F { pub fn reverse_slice(values: &[Fr]) -> Vec { values.iter().rev().copied().collect() } + +#[cfg(test)] +#[expect( + clippy::unwrap_used, + reason = "tests assert the success and error paths directly" +)] +mod tests { + use super::{Fr, NamedEvalFamilyPlan, RuntimePlanError, ValueStore}; + + #[test] + fn value_store_evaluates_named_eval_families_as_field_vectors() { + let mut store = ValueStore::default(); + store.insert_scalar("eval.a", Fr::from_u64(2)); + store.insert_scalar("eval.b", Fr::from_u64(3)); + + store + .evaluate_named_eval_families(&[NamedEvalFamilyPlan { + symbol: "family.ab", + evals: &["eval.a", "eval.b"], + }]) + .unwrap(); + + assert_eq!( + store.try_field_vector("family.ab"), + Some([Fr::from_u64(2), Fr::from_u64(3)].as_slice()) + ); + } + + #[test] + fn value_store_rejects_named_eval_family_missing_eval() { + let mut store = ValueStore::::default(); + let error = store + .evaluate_named_eval_families(&[NamedEvalFamilyPlan { + symbol: "family.ab", + evals: &["eval.missing"], + }]) + .unwrap_err(); + + assert_eq!( + error, + RuntimePlanError::MissingValue { + symbol: "eval.missing" + } + ); + } +} diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 78e3e29f2d..6328cbf06c 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -587,8 +587,11 @@ and verifier opening-flow validation to consume plan-derived value sources instead of rebuilding point sources in each stage. Verifier field-flow validation also consumes plan-derived scalar sources; the remaining CPU scalar source builders are explicitly scoped to prover/role-neutral validation. -Field-vector values, eval-family values, and relation-output execution are not -yet lowered through a single typed graph. +Stage 5/6 verifier programs now also emit explicit indexed eval-family rows as +runtime `NamedEvalFamilyPlan` slices and seed them into `ValueStore` as +field-vector values after sumcheck output observation. Relation-output execution +is not yet lowered through a single typed graph, and output eval families are +still scalar-output claim machinery rather than first-class value rows. ### Dialect changes diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index b85d32da96..cbd15eb360 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -14,7 +14,7 @@ use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, }; -use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; +use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; use crate::protocols::jolt::verifier_output_claims::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, @@ -1519,6 +1519,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); if self.role == Role::Verifier { + source.push_str(&self.emit_indexed_eval_family_constants()?); source.push_str(&self.emit_verifier_output_claim_constants()?); } let output_claims_field = if self.role == Role::Verifier { @@ -2010,6 +2011,16 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); format!("pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[\n{evals}\n];\n\n") } + fn emit_indexed_eval_family_constants(&self) -> Result { + Ok(verifier_eval_families::emit_runtime_slice_constant( + &self.verifier_plan()?.indexed_eval_families, + "pub ", + "STAGE5_INDEXED_EVAL_FAMILY", + "STAGE5_INDEXED_EVAL_FAMILIES", + "bolt_verifier_runtime::NamedEvalFamilyPlan", + )) + } + fn emit_named_eval_family_constants(&self) -> Result { let plan = Stage5InstructionReadRafEmitPlan::from_eval_families( &self.verifier_plan()?.indexed_eval_families, @@ -2434,6 +2445,7 @@ fn observe_stage5_sumcheck_output( }, |symbol| VerifyStage5Error::MissingValue { symbol }, )?; + store.evaluate_named_eval_families(STAGE5_INDEXED_EVAL_FAMILIES)?; store.evaluate_available_points( program.point_slices, program.point_concats, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 11c54321d9..f9ae601e24 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -15,7 +15,7 @@ use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_output_claim_plan, STAGE6_BYTECODE_RA_EVAL_FAMILY, }; -use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; +use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; use crate::protocols::jolt::verifier_output_claims::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, @@ -1618,6 +1618,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); if self.role == Role::Verifier { let bytecode_ra_evals = stage6_bytecode_read_raf_eval_family(&self.verifier_plan()?.indexed_eval_families)?; + source.push_str(&self.emit_indexed_eval_family_constants()?); source.push_str(&emit_stage6_bytecode_read_raf_plan_constants( bytecode_ra_evals, )); @@ -2122,6 +2123,16 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); ) } + fn emit_indexed_eval_family_constants(&self) -> Result { + Ok(verifier_eval_families::emit_runtime_slice_constant( + &self.verifier_plan()?.indexed_eval_families, + "pub ", + "STAGE6_INDEXED_EVAL_FAMILY", + "STAGE6_INDEXED_EVAL_FAMILIES", + "bolt_verifier_runtime::NamedEvalFamilyPlan", + )) + } + fn emit_verifier_output_claim_constants(&self) -> Result { super::output_claims::emit_verifier_output_claim_constants( "Stage6", @@ -2590,6 +2601,7 @@ fn observe_stage6_sumcheck_output( }, |symbol| VerifyStage6Error::MissingValue { symbol }, )?; + store.evaluate_named_eval_families(STAGE6_INDEXED_EVAL_FAMILIES)?; store.evaluate_available_points( program.point_slices, program.point_concats, diff --git a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs index 182fc8607c..00c8fe0835 100644 --- a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs +++ b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs @@ -52,13 +52,49 @@ impl IndexedEvalFamilyPlan { } } +pub(crate) fn emit_runtime_slice_constant( + families: &[IndexedEvalFamilyPlan], + visibility: &str, + names_prefix: &str, + families_const: &str, + family_type: &str, +) -> String { + let mut source = String::new(); + let mut family_rows = Vec::with_capacity(families.len()); + for (index, family) in families.iter().enumerate() { + let names_const = format!("{names_prefix}_{index}_NAMES"); + let names_source = family + .evals + .iter() + .map(|name| rust_str(name)) + .collect::>() + .join(", "); + push_format( + &mut source, + format_args!("#[rustfmt::skip]\nconst {names_const}: &[&str] = &[{names_source}];\n"), + ); + family_rows.push(format!( + " {family_type} {{ symbol: {}, evals: {names_const} }},", + rust_str(&family.symbol), + )); + } + push_format( + &mut source, + format_args!( + "{visibility}const {families_const}: &[{family_type}] = &[\n{}\n];\n\n", + family_rows.join("\n"), + ), + ); + source +} + fn rust_str(value: &str) -> String { format!("{value:?}") } #[cfg(test)] mod tests { - use super::IndexedEvalFamilyPlan; + use super::{emit_runtime_slice_constant, IndexedEvalFamilyPlan}; #[test] fn find_rejects_missing_families() { @@ -90,4 +126,25 @@ mod tests { assert!(error.contains("duplicate eval family `stage.eval.BytecodeRa`")); } + + #[test] + fn emit_runtime_slice_constant_groups_eval_families() { + let source = emit_runtime_slice_constant( + &[IndexedEvalFamilyPlan { + symbol: "stage.eval.BytecodeRa".to_owned(), + evals: vec![ + "stage.eval.BytecodeRa_0".to_owned(), + "stage.eval.BytecodeRa_1".to_owned(), + ], + }], + "pub ", + "STAGE_EVAL_FAMILY", + "STAGE_EVAL_FAMILIES", + "bolt_verifier_runtime::NamedEvalFamilyPlan", + ); + + assert!(source.contains("pub const STAGE_EVAL_FAMILIES")); + assert!(source.contains("STAGE_EVAL_FAMILY_0_NAMES")); + assert!(source.contains("stage.eval.BytecodeRa_1")); + } } From 8910cdc41974a3a60e42eaa84186d9e096b9fb6c Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 15:36:47 -0600 Subject: [PATCH 093/171] refactor(bolt): consume eval family vectors --- crates/bolt-verifier-runtime/src/lib.rs | 49 +++++++++- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 6 +- .../protocols/jolt/emit/rust/output_claims.rs | 5 +- .../jolt/stage5_instruction_read_raf_plan.rs | 10 +- .../jolt/stage6_bytecode_read_raf_plan.rs | 20 ++-- .../protocols/jolt/verifier_output_claims.rs | 3 + crates/bolt/tests/commitment_ir.rs | 11 +-- crates/jolt-equivalence/src/plan_adapters.rs | 7 ++ crates/jolt-verifier/src/stages/stage5.rs | 95 ++++++++++--------- crates/jolt-verifier/src/stages/stage6.rs | 27 ++++-- 10 files changed, 156 insertions(+), 77 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 6ff5176db7..48057eb8d1 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -405,6 +405,7 @@ pub struct SumcheckOutputEvalFamilyPlan { pub struct SumcheckOutputProductFamilyTermPlan { pub gamma_power_offset: usize, pub evals: &'static [&'static str], + pub eval_families: &'static [&'static str], pub factors: &'static [&'static str], } @@ -1483,7 +1484,7 @@ fn evaluate_sumcheck_output_product_family( let gamma = output_family_gamma(family.gamma, store, scratch)?; let mut result = Fr::from_u64(0); for term in family.terms { - if term.evals.is_empty() && term.factors.is_empty() { + if term.evals.is_empty() && term.eval_families.is_empty() && term.factors.is_empty() { return Err(RuntimePlanError::InvalidInputLength { input: family.symbol, expected: 1, @@ -1497,6 +1498,21 @@ fn evaluate_sumcheck_output_product_family( .ok_or(RuntimePlanError::MissingValue { symbol })?; product *= value; } + for &family_symbol in term.eval_families { + let values = store.field_vector_or(family_symbol, |symbol| { + RuntimePlanError::MissingValue { symbol } + })?; + if values.is_empty() { + return Err(RuntimePlanError::InvalidInputLength { + input: family_symbol, + expected: 1, + actual: 0, + }); + } + for value in values { + product *= *value; + } + } result += product; } Ok(result) @@ -1849,7 +1865,11 @@ pub fn reverse_slice(values: &[Fr]) -> Vec { reason = "tests assert the success and error paths directly" )] mod tests { - use super::{Fr, NamedEvalFamilyPlan, RuntimePlanError, ValueStore}; + use super::{ + evaluate_sumcheck_output_product_family, Fr, NamedEvalFamilyPlan, RuntimePlanError, + ScratchScalars, SumcheckOutputProductFamilyPlan, SumcheckOutputProductFamilyTermPlan, + ValueStore, + }; #[test] fn value_store_evaluates_named_eval_families_as_field_vectors() { @@ -1887,4 +1907,29 @@ mod tests { } ); } + + #[test] + fn product_family_multiplies_field_vector_terms() { + let mut store = ValueStore::default(); + store.insert_scalar("scalar.factor", Fr::from_u64(5)); + store.insert_field_vector("family.ab", vec![Fr::from_u64(2), Fr::from_u64(3)]); + + let value = evaluate_sumcheck_output_product_family( + &SumcheckOutputProductFamilyPlan { + symbol: "product.family", + gamma: None, + terms: &[SumcheckOutputProductFamilyTermPlan { + gamma_power_offset: 0, + evals: &["scalar.factor"], + eval_families: &["family.ab"], + factors: &[], + }], + }, + &store, + &ScratchScalars::default(), + ) + .unwrap(); + + assert_eq!(value, Fr::from_u64(30)); + } } diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 6328cbf06c..975ad010b7 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -590,8 +590,10 @@ source builders are explicitly scoped to prover/role-neutral validation. Stage 5/6 verifier programs now also emit explicit indexed eval-family rows as runtime `NamedEvalFamilyPlan` slices and seed them into `ValueStore` as field-vector values after sumcheck output observation. Relation-output execution -is not yet lowered through a single typed graph, and output eval families are -still scalar-output claim machinery rather than first-class value rows. +has started consuming those vectors: output product-family terms can reference +an eval-family vector by symbol, and Stage 5 instruction RA / Stage 6 bytecode +RA products use that path. Output eval families are still scalar-output claim +machinery rather than first-class value rows. ### Dialect changes diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index 46ca003869..4706457d08 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -178,10 +178,13 @@ fn emit_product_family_constants( for (term_index, term) in family.terms.iter().enumerate() { let evals_name = format!("{prefix}_TERM_{term_index}_EVALS"); let evals = emit_str_slice_or_inline(source, &evals_name, &term.evals); + let eval_families_name = format!("{prefix}_TERM_{term_index}_EVAL_FAMILIES"); + let eval_families = + emit_str_slice_or_inline(source, &eval_families_name, &term.eval_families); let factors_name = format!("{prefix}_TERM_{term_index}_FACTORS"); let factors = emit_str_slice_or_inline(source, &factors_name, &term.factors); term_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan {{ gamma_power_offset: {}, evals: {evals}, factors: {factors} }},", + " bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan {{ gamma_power_offset: {}, evals: {evals}, eval_families: {eval_families}, factors: {factors} }},", term.gamma_power_offset )); } diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index c33025191b..0fa9ecb9e1 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -110,6 +110,7 @@ impl Stage5InstructionReadRafEmitPlan { |(flag_eval, table_value)| SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: vec![table_value.symbol.clone(), flag_eval.clone()], + eval_families: Vec::new(), factors: Vec::new(), }, ) @@ -120,7 +121,8 @@ impl Stage5InstructionReadRafEmitPlan { gamma: None, terms: vec![SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, - evals: self.instruction_ra_evals.evals.clone(), + evals: Vec::new(), + eval_families: vec![self.instruction_ra_evals.symbol.clone()], factors: Vec::new(), }], }; @@ -431,7 +433,11 @@ mod tests { ); assert_eq!( output_plan.claim.product_families[1].terms[0].evals, - vec!["stage5.instruction_read_raf.eval.InstructionRa_0".to_owned()] + Vec::::new() + ); + assert_eq!( + output_plan.claim.product_families[1].terms[0].eval_families, + vec![STAGE5_INSTRUCTION_RA_EVAL_FAMILY.to_owned()] ); assert_eq!( output_plan.claim.local_scalars, diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 5ed30290ee..eb57d5e07d 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -360,9 +360,8 @@ impl BytecodeReadRafPlan { gamma: None, terms: vec![SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, - evals: std::iter::once(self.output_contribution.to_owned()) - .chain(bytecode_ra_evals.evals.iter().cloned()) - .collect(), + evals: vec![self.output_contribution.to_owned()], + eval_families: vec![bytecode_ra_evals.symbol.clone()], factors: Vec::new(), }], }; @@ -577,7 +576,8 @@ mod tests { use super::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_output_claim_plan, stage6_bytecode_read_raf_output_contribution_symbol, BytecodeFlag, BytecodeOutputTermPlan, - BytecodeReadRafTermPlan, BytecodeRegister, STAGE6_BYTECODE_READ_RAF_PLAN, + BytecodeReadRafTermPlan, BytecodeRegister, STAGE6_BYTECODE_RA_EVAL_FAMILY, + STAGE6_BYTECODE_READ_RAF_PLAN, }; fn bytecode_ra_evals() -> IndexedEvalFamilyPlan { @@ -699,13 +699,11 @@ mod tests { ); assert_eq!( claim.product_families[0].terms[0].evals, - vec![ - stage6_bytecode_read_raf_output_contribution_symbol().to_owned(), - "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), - "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), - "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(), - "stage6.bytecode_read_raf.eval.BytecodeRa_3".to_owned(), - ] + vec![stage6_bytecode_read_raf_output_contribution_symbol().to_owned()] + ); + assert_eq!( + claim.product_families[0].terms[0].eval_families, + vec![STAGE6_BYTECODE_RA_EVAL_FAMILY.to_owned()] ); } diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index c8a41f9cf7..52453ab939 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -220,6 +220,7 @@ pub struct SumcheckOutputEvalFamilyPlan { pub struct SumcheckOutputProductFamilyTermPlan { pub gamma_power_offset: usize, pub evals: Vec, + pub eval_families: Vec, pub factors: Vec, } @@ -413,6 +414,7 @@ pub fn parse_output_product_family_plan( terms.push(SumcheckOutputProductFamilyTermPlan { gamma_power_offset, evals: evals[eval_offset..eval_end].to_vec(), + eval_families: Vec::new(), factors: factors[factor_offset..factor_end].to_vec(), }); eval_offset = eval_end; @@ -1303,6 +1305,7 @@ mod tests { terms: vec![SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: vec!["product.eval".to_owned()], + eval_families: Vec::new(), factors: vec!["product.factor.expr".to_owned()], }], }; diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 2c8a94441c..cd4f6ef5af 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1776,12 +1776,11 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(bytecode_claims[0].product_families.len(), 1); assert_eq!( bytecode_claims[0].product_families[0].terms[0].evals, - vec![ - "stage6.bytecode_read_raf.output.contribution".to_owned(), - "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), - "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), - "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned() - ] + vec!["stage6.bytecode_read_raf.output.contribution".to_owned()] + ); + assert_eq!( + bytecode_claims[0].product_families[0].terms[0].eval_families, + vec!["stage6.bytecode_read_raf.eval.BytecodeRa".to_owned()] ); assert!(bytecode_claims[0].function_families.is_empty()); assert_eq!(prover_program.point_zeros.len(), 1); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 73ac99af4c..ced510a987 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -711,6 +711,13 @@ macro_rules! define_stage_adapter_impl { .map(|symbol| super::leak_str(symbol)) .collect(), ), + eval_families: super::leak_slice( + term + .eval_families + .iter() + .map(|symbol| super::leak_str(symbol)) + .collect(), + ), factors: super::leak_slice( term .factors diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 080d6c0383..1a7e05e4cd 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -358,6 +358,15 @@ pub const STAGE5_OPENING_EQUALITIES: &[Stage5OpeningClaimEqualityPlan] = &[ pub const STAGE5_OPENING_BATCHES: &[Stage5OpeningBatchPlan] = &[ Stage5OpeningBatchPlan { symbol: "stage5.openings", stage: "stage5", proof_slot: "stage5.openings", policy: "jolt_stage5_output_order", count: 53, ordered_claims: &["stage5.instruction_read_raf.opening.LookupTableFlag_0", "stage5.instruction_read_raf.opening.LookupTableFlag_1", "stage5.instruction_read_raf.opening.LookupTableFlag_2", "stage5.instruction_read_raf.opening.LookupTableFlag_3", "stage5.instruction_read_raf.opening.LookupTableFlag_4", "stage5.instruction_read_raf.opening.LookupTableFlag_5", "stage5.instruction_read_raf.opening.LookupTableFlag_6", "stage5.instruction_read_raf.opening.LookupTableFlag_7", "stage5.instruction_read_raf.opening.LookupTableFlag_8", "stage5.instruction_read_raf.opening.LookupTableFlag_9", "stage5.instruction_read_raf.opening.LookupTableFlag_10", "stage5.instruction_read_raf.opening.LookupTableFlag_11", "stage5.instruction_read_raf.opening.LookupTableFlag_12", "stage5.instruction_read_raf.opening.LookupTableFlag_13", "stage5.instruction_read_raf.opening.LookupTableFlag_14", "stage5.instruction_read_raf.opening.LookupTableFlag_15", "stage5.instruction_read_raf.opening.LookupTableFlag_16", "stage5.instruction_read_raf.opening.LookupTableFlag_17", "stage5.instruction_read_raf.opening.LookupTableFlag_18", "stage5.instruction_read_raf.opening.LookupTableFlag_19", "stage5.instruction_read_raf.opening.LookupTableFlag_20", "stage5.instruction_read_raf.opening.LookupTableFlag_21", "stage5.instruction_read_raf.opening.LookupTableFlag_22", "stage5.instruction_read_raf.opening.LookupTableFlag_23", "stage5.instruction_read_raf.opening.LookupTableFlag_24", "stage5.instruction_read_raf.opening.LookupTableFlag_25", "stage5.instruction_read_raf.opening.LookupTableFlag_26", "stage5.instruction_read_raf.opening.LookupTableFlag_27", "stage5.instruction_read_raf.opening.LookupTableFlag_28", "stage5.instruction_read_raf.opening.LookupTableFlag_29", "stage5.instruction_read_raf.opening.LookupTableFlag_30", "stage5.instruction_read_raf.opening.LookupTableFlag_31", "stage5.instruction_read_raf.opening.LookupTableFlag_32", "stage5.instruction_read_raf.opening.LookupTableFlag_33", "stage5.instruction_read_raf.opening.LookupTableFlag_34", "stage5.instruction_read_raf.opening.LookupTableFlag_35", "stage5.instruction_read_raf.opening.LookupTableFlag_36", "stage5.instruction_read_raf.opening.LookupTableFlag_37", "stage5.instruction_read_raf.opening.LookupTableFlag_38", "stage5.instruction_read_raf.opening.LookupTableFlag_39", "stage5.instruction_read_raf.opening.LookupTableFlag_40", "stage5.instruction_read_raf.opening.InstructionRa_0", "stage5.instruction_read_raf.opening.InstructionRa_1", "stage5.instruction_read_raf.opening.InstructionRa_2", "stage5.instruction_read_raf.opening.InstructionRa_3", "stage5.instruction_read_raf.opening.InstructionRa_4", "stage5.instruction_read_raf.opening.InstructionRa_5", "stage5.instruction_read_raf.opening.InstructionRa_6", "stage5.instruction_read_raf.opening.InstructionRa_7", "stage5.instruction_read_raf.opening.InstructionRafFlag", "stage5.ram_ra_claim_reduction.opening.RamRa", "stage5.registers_val_evaluation.opening.RdInc", "stage5.registers_val_evaluation.opening.RdWa"], claim_operands: &["stage5.instruction_read_raf.opening.LookupTableFlag_0", "stage5.instruction_read_raf.opening.LookupTableFlag_1", "stage5.instruction_read_raf.opening.LookupTableFlag_2", "stage5.instruction_read_raf.opening.LookupTableFlag_3", "stage5.instruction_read_raf.opening.LookupTableFlag_4", "stage5.instruction_read_raf.opening.LookupTableFlag_5", "stage5.instruction_read_raf.opening.LookupTableFlag_6", "stage5.instruction_read_raf.opening.LookupTableFlag_7", "stage5.instruction_read_raf.opening.LookupTableFlag_8", "stage5.instruction_read_raf.opening.LookupTableFlag_9", "stage5.instruction_read_raf.opening.LookupTableFlag_10", "stage5.instruction_read_raf.opening.LookupTableFlag_11", "stage5.instruction_read_raf.opening.LookupTableFlag_12", "stage5.instruction_read_raf.opening.LookupTableFlag_13", "stage5.instruction_read_raf.opening.LookupTableFlag_14", "stage5.instruction_read_raf.opening.LookupTableFlag_15", "stage5.instruction_read_raf.opening.LookupTableFlag_16", "stage5.instruction_read_raf.opening.LookupTableFlag_17", "stage5.instruction_read_raf.opening.LookupTableFlag_18", "stage5.instruction_read_raf.opening.LookupTableFlag_19", "stage5.instruction_read_raf.opening.LookupTableFlag_20", "stage5.instruction_read_raf.opening.LookupTableFlag_21", "stage5.instruction_read_raf.opening.LookupTableFlag_22", "stage5.instruction_read_raf.opening.LookupTableFlag_23", "stage5.instruction_read_raf.opening.LookupTableFlag_24", "stage5.instruction_read_raf.opening.LookupTableFlag_25", "stage5.instruction_read_raf.opening.LookupTableFlag_26", "stage5.instruction_read_raf.opening.LookupTableFlag_27", "stage5.instruction_read_raf.opening.LookupTableFlag_28", "stage5.instruction_read_raf.opening.LookupTableFlag_29", "stage5.instruction_read_raf.opening.LookupTableFlag_30", "stage5.instruction_read_raf.opening.LookupTableFlag_31", "stage5.instruction_read_raf.opening.LookupTableFlag_32", "stage5.instruction_read_raf.opening.LookupTableFlag_33", "stage5.instruction_read_raf.opening.LookupTableFlag_34", "stage5.instruction_read_raf.opening.LookupTableFlag_35", "stage5.instruction_read_raf.opening.LookupTableFlag_36", "stage5.instruction_read_raf.opening.LookupTableFlag_37", "stage5.instruction_read_raf.opening.LookupTableFlag_38", "stage5.instruction_read_raf.opening.LookupTableFlag_39", "stage5.instruction_read_raf.opening.LookupTableFlag_40", "stage5.instruction_read_raf.opening.InstructionRa_0", "stage5.instruction_read_raf.opening.InstructionRa_1", "stage5.instruction_read_raf.opening.InstructionRa_2", "stage5.instruction_read_raf.opening.InstructionRa_3", "stage5.instruction_read_raf.opening.InstructionRa_4", "stage5.instruction_read_raf.opening.InstructionRa_5", "stage5.instruction_read_raf.opening.InstructionRa_6", "stage5.instruction_read_raf.opening.InstructionRa_7", "stage5.instruction_read_raf.opening.InstructionRafFlag", "stage5.ram_ra_claim_reduction.opening.RamRa", "stage5.registers_val_evaluation.opening.RdInc", "stage5.registers_val_evaluation.opening.RdWa"] }, ]; +#[rustfmt::skip] +const STAGE5_INDEXED_EVAL_FAMILY_0_NAMES: &[&str] = &["stage5.instruction_read_raf.eval.LookupTableFlag_0", "stage5.instruction_read_raf.eval.LookupTableFlag_1", "stage5.instruction_read_raf.eval.LookupTableFlag_2", "stage5.instruction_read_raf.eval.LookupTableFlag_3", "stage5.instruction_read_raf.eval.LookupTableFlag_4", "stage5.instruction_read_raf.eval.LookupTableFlag_5", "stage5.instruction_read_raf.eval.LookupTableFlag_6", "stage5.instruction_read_raf.eval.LookupTableFlag_7", "stage5.instruction_read_raf.eval.LookupTableFlag_8", "stage5.instruction_read_raf.eval.LookupTableFlag_9", "stage5.instruction_read_raf.eval.LookupTableFlag_10", "stage5.instruction_read_raf.eval.LookupTableFlag_11", "stage5.instruction_read_raf.eval.LookupTableFlag_12", "stage5.instruction_read_raf.eval.LookupTableFlag_13", "stage5.instruction_read_raf.eval.LookupTableFlag_14", "stage5.instruction_read_raf.eval.LookupTableFlag_15", "stage5.instruction_read_raf.eval.LookupTableFlag_16", "stage5.instruction_read_raf.eval.LookupTableFlag_17", "stage5.instruction_read_raf.eval.LookupTableFlag_18", "stage5.instruction_read_raf.eval.LookupTableFlag_19", "stage5.instruction_read_raf.eval.LookupTableFlag_20", "stage5.instruction_read_raf.eval.LookupTableFlag_21", "stage5.instruction_read_raf.eval.LookupTableFlag_22", "stage5.instruction_read_raf.eval.LookupTableFlag_23", "stage5.instruction_read_raf.eval.LookupTableFlag_24", "stage5.instruction_read_raf.eval.LookupTableFlag_25", "stage5.instruction_read_raf.eval.LookupTableFlag_26", "stage5.instruction_read_raf.eval.LookupTableFlag_27", "stage5.instruction_read_raf.eval.LookupTableFlag_28", "stage5.instruction_read_raf.eval.LookupTableFlag_29", "stage5.instruction_read_raf.eval.LookupTableFlag_30", "stage5.instruction_read_raf.eval.LookupTableFlag_31", "stage5.instruction_read_raf.eval.LookupTableFlag_32", "stage5.instruction_read_raf.eval.LookupTableFlag_33", "stage5.instruction_read_raf.eval.LookupTableFlag_34", "stage5.instruction_read_raf.eval.LookupTableFlag_35", "stage5.instruction_read_raf.eval.LookupTableFlag_36", "stage5.instruction_read_raf.eval.LookupTableFlag_37", "stage5.instruction_read_raf.eval.LookupTableFlag_38", "stage5.instruction_read_raf.eval.LookupTableFlag_39", "stage5.instruction_read_raf.eval.LookupTableFlag_40"]; +#[rustfmt::skip] +const STAGE5_INDEXED_EVAL_FAMILY_1_NAMES: &[&str] = &["stage5.instruction_read_raf.eval.InstructionRa_0", "stage5.instruction_read_raf.eval.InstructionRa_1", "stage5.instruction_read_raf.eval.InstructionRa_2", "stage5.instruction_read_raf.eval.InstructionRa_3", "stage5.instruction_read_raf.eval.InstructionRa_4", "stage5.instruction_read_raf.eval.InstructionRa_5", "stage5.instruction_read_raf.eval.InstructionRa_6", "stage5.instruction_read_raf.eval.InstructionRa_7"]; +pub const STAGE5_INDEXED_EVAL_FAMILIES: &[bolt_verifier_runtime::NamedEvalFamilyPlan] = &[ + bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.LookupTableFlag", evals: STAGE5_INDEXED_EVAL_FAMILY_0_NAMES }, + bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.InstructionRa", evals: STAGE5_INDEXED_EVAL_FAMILY_1_NAMES }, +]; + pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.ram_raf.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.ram_read_write.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, @@ -373,51 +382,50 @@ pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage5StructuredPolynomialEva ]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"], eval_families: &[], factors: &[] }, ]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_EVALS: &[&str] = &["stage5.instruction_read_raf.eval.InstructionRa_0", "stage5.instruction_read_raf.eval.InstructionRa_1", "stage5.instruction_read_raf.eval.InstructionRa_2", "stage5.instruction_read_raf.eval.InstructionRa_3", "stage5.instruction_read_raf.eval.InstructionRa_4", "stage5.instruction_read_raf.eval.InstructionRa_5", "stage5.instruction_read_raf.eval.InstructionRa_6", "stage5.instruction_read_raf.eval.InstructionRa_7"]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERM_0_EVALS, factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &[], eval_families: &["stage5.instruction_read_raf.eval.InstructionRa"], factors: &[] }, ]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.LookupTableValues", gamma: None, terms: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, @@ -662,6 +670,7 @@ fn observe_stage5_sumcheck_output( }, |symbol| VerifyStage5Error::MissingValue { symbol }, )?; + store.evaluate_named_eval_families(STAGE5_INDEXED_EVAL_FAMILIES)?; store.evaluate_available_points( program.point_slices, program.point_concats, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 29459c0ddd..2c53c29c2f 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -548,6 +548,12 @@ pub const STAGE6_OPENING_EQUALITIES: &[Stage6OpeningClaimEqualityPlan] = &[ pub const STAGE6_OPENING_BATCHES: &[Stage6OpeningBatchPlan] = &[ Stage6OpeningBatchPlan { symbol: "stage6.openings", stage: "stage6", proof_slot: "stage6.openings", policy: "jolt_stage6_output_order", count: 81, ordered_claims: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"], claim_operands: &["stage6.bytecode_read_raf.opening.BytecodeRa_0", "stage6.bytecode_read_raf.opening.BytecodeRa_1", "stage6.bytecode_read_raf.opening.BytecodeRa_2", "stage6.booleanity.opening.InstructionRa_0", "stage6.booleanity.opening.InstructionRa_1", "stage6.booleanity.opening.InstructionRa_2", "stage6.booleanity.opening.InstructionRa_3", "stage6.booleanity.opening.InstructionRa_4", "stage6.booleanity.opening.InstructionRa_5", "stage6.booleanity.opening.InstructionRa_6", "stage6.booleanity.opening.InstructionRa_7", "stage6.booleanity.opening.InstructionRa_8", "stage6.booleanity.opening.InstructionRa_9", "stage6.booleanity.opening.InstructionRa_10", "stage6.booleanity.opening.InstructionRa_11", "stage6.booleanity.opening.InstructionRa_12", "stage6.booleanity.opening.InstructionRa_13", "stage6.booleanity.opening.InstructionRa_14", "stage6.booleanity.opening.InstructionRa_15", "stage6.booleanity.opening.InstructionRa_16", "stage6.booleanity.opening.InstructionRa_17", "stage6.booleanity.opening.InstructionRa_18", "stage6.booleanity.opening.InstructionRa_19", "stage6.booleanity.opening.InstructionRa_20", "stage6.booleanity.opening.InstructionRa_21", "stage6.booleanity.opening.InstructionRa_22", "stage6.booleanity.opening.InstructionRa_23", "stage6.booleanity.opening.InstructionRa_24", "stage6.booleanity.opening.InstructionRa_25", "stage6.booleanity.opening.InstructionRa_26", "stage6.booleanity.opening.InstructionRa_27", "stage6.booleanity.opening.InstructionRa_28", "stage6.booleanity.opening.InstructionRa_29", "stage6.booleanity.opening.InstructionRa_30", "stage6.booleanity.opening.InstructionRa_31", "stage6.booleanity.opening.BytecodeRa_0", "stage6.booleanity.opening.BytecodeRa_1", "stage6.booleanity.opening.BytecodeRa_2", "stage6.booleanity.opening.RamRa_0", "stage6.booleanity.opening.RamRa_1", "stage6.booleanity.opening.RamRa_2", "stage6.booleanity.opening.RamRa_3", "stage6.hamming_booleanity.opening.HammingWeight", "stage6.ram_ra_virtual.opening.RamRa_0", "stage6.ram_ra_virtual.opening.RamRa_1", "stage6.ram_ra_virtual.opening.RamRa_2", "stage6.ram_ra_virtual.opening.RamRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_0", "stage6.instruction_ra_virtual.opening.InstructionRa_1", "stage6.instruction_ra_virtual.opening.InstructionRa_2", "stage6.instruction_ra_virtual.opening.InstructionRa_3", "stage6.instruction_ra_virtual.opening.InstructionRa_4", "stage6.instruction_ra_virtual.opening.InstructionRa_5", "stage6.instruction_ra_virtual.opening.InstructionRa_6", "stage6.instruction_ra_virtual.opening.InstructionRa_7", "stage6.instruction_ra_virtual.opening.InstructionRa_8", "stage6.instruction_ra_virtual.opening.InstructionRa_9", "stage6.instruction_ra_virtual.opening.InstructionRa_10", "stage6.instruction_ra_virtual.opening.InstructionRa_11", "stage6.instruction_ra_virtual.opening.InstructionRa_12", "stage6.instruction_ra_virtual.opening.InstructionRa_13", "stage6.instruction_ra_virtual.opening.InstructionRa_14", "stage6.instruction_ra_virtual.opening.InstructionRa_15", "stage6.instruction_ra_virtual.opening.InstructionRa_16", "stage6.instruction_ra_virtual.opening.InstructionRa_17", "stage6.instruction_ra_virtual.opening.InstructionRa_18", "stage6.instruction_ra_virtual.opening.InstructionRa_19", "stage6.instruction_ra_virtual.opening.InstructionRa_20", "stage6.instruction_ra_virtual.opening.InstructionRa_21", "stage6.instruction_ra_virtual.opening.InstructionRa_22", "stage6.instruction_ra_virtual.opening.InstructionRa_23", "stage6.instruction_ra_virtual.opening.InstructionRa_24", "stage6.instruction_ra_virtual.opening.InstructionRa_25", "stage6.instruction_ra_virtual.opening.InstructionRa_26", "stage6.instruction_ra_virtual.opening.InstructionRa_27", "stage6.instruction_ra_virtual.opening.InstructionRa_28", "stage6.instruction_ra_virtual.opening.InstructionRa_29", "stage6.instruction_ra_virtual.opening.InstructionRa_30", "stage6.instruction_ra_virtual.opening.InstructionRa_31", "stage6.inc_claim_reduction.opening.RamInc", "stage6.inc_claim_reduction.opening.RdInc"] }, ]; +#[rustfmt::skip] +const STAGE6_INDEXED_EVAL_FAMILY_0_NAMES: &[&str] = &["stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"]; +pub const STAGE6_INDEXED_EVAL_FAMILIES: &[bolt_verifier_runtime::NamedEvalFamilyPlan] = &[ + bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage6.bytecode_read_raf.eval.BytecodeRa", evals: STAGE6_INDEXED_EVAL_FAMILY_0_NAMES }, +]; + #[rustfmt::skip] const STAGE6_BYTECODE_RA_EVAL_NAMES: &[&str] = &["stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"]; @@ -696,7 +702,7 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage6StructuredPolynomialEva ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"], factors: &["stage6.ram_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"], eval_families: &[], factors: &["stage6.ram_ra_virtual.output.eq.Cycle"] }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, @@ -707,14 +713,14 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES: &[Stage6StructuredPolynomialEva ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 3, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 4, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 5, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 6, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31"], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 3, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 4, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 5, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 6, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: Some("stage6.instruction_ra_virtual.gamma"), terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERMS }, @@ -744,7 +750,7 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_VALUES: &[Stage6StructuredPolynomialEva ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"], factors: &[] }, + bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.bytecode_read_raf.output.contribution"], eval_families: &["stage6.bytecode_read_raf.eval.BytecodeRa"], factors: &[] }, ]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERMS }, @@ -1016,6 +1022,7 @@ fn observe_stage6_sumcheck_output( }, |symbol| VerifyStage6Error::MissingValue { symbol }, )?; + store.evaluate_named_eval_families(STAGE6_INDEXED_EVAL_FAMILIES)?; store.evaluate_available_points( program.point_slices, program.point_concats, From 2fb7348b77c5bf1e469e802da5b57a5d52dffdd9 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 18:41:44 -0600 Subject: [PATCH 094/171] refactor(bolt): reuse eval family plan rows --- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 12 ++- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../src/protocols/jolt/emit/rust/stage6.rs | 40 ++++----- .../jolt/stage5_instruction_read_raf_plan.rs | 81 ++++++++++++------- .../jolt/stage6_bytecode_read_raf_plan.rs | 64 ++++++++------- .../protocols/jolt/verifier_eval_families.rs | 67 +++++++-------- crates/jolt-verifier/src/stages/stage5.rs | 14 +--- crates/jolt-verifier/src/stages/stage6.rs | 6 +- 8 files changed, 154 insertions(+), 132 deletions(-) diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 975ad010b7..33f0c0eeb9 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -592,8 +592,11 @@ runtime `NamedEvalFamilyPlan` slices and seed them into `ValueStore` as field-vector values after sumcheck output observation. Relation-output execution has started consuming those vectors: output product-family terms can reference an eval-family vector by symbol, and Stage 5 instruction RA / Stage 6 bytecode -RA products use that path. Output eval families are still scalar-output claim -machinery rather than first-class value rows. +RA products use that path. The Stage 5 instruction read-RAF and Stage 6 +bytecode read-RAF relation plans now reference the same plan-level +`STAGE*_INDEXED_EVAL_FAMILIES` rows instead of emitting duplicate +relation-local `NamedEvalFamilyPlan` constants. Output eval families are still +scalar-output claim machinery rather than first-class value rows. ### Dialect changes @@ -805,7 +808,10 @@ The existing scalar `sumcheck_eval` ops remain the source of the serialized named evals. The family row is an explicit membership declaration consumed by the verifier-plan layer. A later S3/S5 value-graph slice can promote this shape to a typed field-vector value if that makes the Rust emission smaller and -clearer. +clearer. On the current stack, the first promotion has landed for Stage 5/6: +the plan-level indexed eval-family rows are emitted as runtime +`NamedEvalFamilyPlan` slices, seeded as field-vector values, and reused by the +relation plans that need the same family contract. ### Runtime additions diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index cbd15eb360..31ebc6a545 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1233,7 +1233,7 @@ impl Stage5CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan, NamedEvalFamilyPlan};\n\ + "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index f9ae601e24..e2515182b3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -12,8 +12,8 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ - emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_output_claim_plan, - STAGE6_BYTECODE_RA_EVAL_FAMILY, + emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, + stage6_bytecode_read_raf_output_claim_plan, STAGE6_BYTECODE_RA_EVAL_FAMILY, }; use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; use crate::protocols::jolt::verifier_output_claims::{ @@ -684,7 +684,10 @@ impl Stage6CpuProgram { Vec::new() }; if role == Role::Verifier { - let bytecode_ra_evals = stage6_bytecode_read_raf_eval_family(&indexed_eval_families)?; + let bytecode_ra_evals = IndexedEvalFamilyPlan::find( + &indexed_eval_families, + STAGE6_BYTECODE_RA_EVAL_FAMILY, + )?; output_claims.push(stage6_bytecode_read_raf_output_claim_plan( bytecode_ra_evals, )); @@ -1616,11 +1619,13 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); if self.role == Role::Verifier { - let bytecode_ra_evals = - stage6_bytecode_read_raf_eval_family(&self.verifier_plan()?.indexed_eval_families)?; + let (bytecode_ra_evals_ref, _) = stage6_bytecode_read_raf_eval_family_ref( + &self.verifier_plan()?.indexed_eval_families, + "STAGE6_INDEXED_EVAL_FAMILIES", + )?; source.push_str(&self.emit_indexed_eval_family_constants()?); source.push_str(&emit_stage6_bytecode_read_raf_plan_constants( - bytecode_ra_evals, + &bytecode_ra_evals_ref, )); source.push_str(&self.emit_verifier_output_claim_constants()?); } @@ -2757,12 +2762,6 @@ fn parse_indexed_eval_family( Ok(IndexedEvalFamilyPlan { symbol, evals }) } -fn stage6_bytecode_read_raf_eval_family( - eval_families: &[IndexedEvalFamilyPlan], -) -> Result<&IndexedEvalFamilyPlan, EmitError> { - IndexedEvalFamilyPlan::find(eval_families, STAGE6_BYTECODE_RA_EVAL_FAMILY) -} - fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) @@ -2886,8 +2885,8 @@ mod tests { use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use super::{ - stage6_bytecode_read_raf_eval_family, stage6_kernel_abi, STAGE6_BYTECODE_RA_EVAL_FAMILY, - STAGE6_KERNEL_ABIS, + stage6_bytecode_read_raf_eval_family_ref, stage6_kernel_abi, + STAGE6_BYTECODE_RA_EVAL_FAMILY, STAGE6_KERNEL_ABIS, }; #[test] @@ -2914,7 +2913,9 @@ mod tests { "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), ], }]; - let family = stage6_bytecode_read_raf_eval_family(&families)?; + let (family_ref, family) = + stage6_bytecode_read_raf_eval_family_ref(&families, "STAGE6_INDEXED_EVAL_FAMILIES")?; + assert_eq!(family_ref, "STAGE6_INDEXED_EVAL_FAMILIES[0]"); assert_eq!( family.evals, vec![ @@ -2933,10 +2934,11 @@ mod tests { evals: vec!["stage6.other.eval.BytecodeRa_0".to_owned()], }]; - let error = stage6_bytecode_read_raf_eval_family(&families) - .err() - .map(|error| error.to_string()) - .unwrap_or_default(); + let error = + stage6_bytecode_read_raf_eval_family_ref(&families, "STAGE6_INDEXED_EVAL_FAMILIES") + .err() + .map(|error| error.to_string()) + .unwrap_or_default(); assert!(error.contains(&format!( "missing eval family `{STAGE6_BYTECODE_RA_EVAL_FAMILY}`" diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 0fa9ecb9e1..bdf9322b9e 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -11,13 +11,16 @@ pub(crate) const STAGE5_TABLE_FLAG_EVAL_FAMILY: &str = "stage5.instruction_read_raf.eval.LookupTableFlag"; pub(crate) const STAGE5_INSTRUCTION_RA_EVAL_FAMILY: &str = "stage5.instruction_read_raf.eval.InstructionRa"; +const STAGE5_INDEXED_EVAL_FAMILIES_CONST: &str = "STAGE5_INDEXED_EVAL_FAMILIES"; #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Stage5InstructionReadRafEmitPlan { pub(crate) point: String, pub(crate) lookup_output_point: String, pub(crate) table_flag_evals: IndexedEvalFamilyPlan, + pub(crate) table_flag_evals_ref: String, pub(crate) instruction_ra_evals: IndexedEvalFamilyPlan, + pub(crate) instruction_ra_evals_ref: String, pub(crate) raf_flag_eval: String, pub(crate) gamma: String, pub(crate) point_values: Vec, @@ -28,16 +31,21 @@ impl Stage5InstructionReadRafEmitPlan { pub(crate) fn from_eval_families( eval_families: &[IndexedEvalFamilyPlan], ) -> Result { - let table_flag_evals = - IndexedEvalFamilyPlan::find(eval_families, STAGE5_TABLE_FLAG_EVAL_FAMILY)?.clone(); - let instruction_ra_evals = - IndexedEvalFamilyPlan::find(eval_families, STAGE5_INSTRUCTION_RA_EVAL_FAMILY)?.clone(); + let (table_flag_evals_index, table_flag_evals) = + IndexedEvalFamilyPlan::find_with_index(eval_families, STAGE5_TABLE_FLAG_EVAL_FAMILY)?; + let (instruction_ra_evals_index, instruction_ra_evals) = + IndexedEvalFamilyPlan::find_with_index( + eval_families, + STAGE5_INSTRUCTION_RA_EVAL_FAMILY, + )?; Ok(Self { point: "stage5.instruction_read_raf.point".to_owned(), lookup_output_point: "stage5.input.stage2.instruction.LookupOutput".to_owned(), point_values: point_value_plans(table_flag_evals.evals.len()), - table_flag_evals, - instruction_ra_evals, + table_flag_evals: table_flag_evals.clone(), + table_flag_evals_ref: indexed_eval_family_ref(table_flag_evals_index), + instruction_ra_evals: instruction_ra_evals.clone(), + instruction_ra_evals_ref: indexed_eval_family_ref(instruction_ra_evals_index), raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag".to_owned(), gamma: "stage5.instruction_read_raf.gamma".to_owned(), log_k: 128, @@ -45,28 +53,7 @@ impl Stage5InstructionReadRafEmitPlan { } pub(crate) fn emit_runtime_constants(&self) -> String { - let families = [ - ( - "STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVAL_NAMES", - "STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS", - &self.table_flag_evals, - ), - ( - "STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES", - "STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS", - &self.instruction_ra_evals, - ), - ]; - let mut source = String::new(); - for (names_const, family_const, family) in families { - source.push_str(&family.emit_runtime_constant( - "pub ", - names_const, - family_const, - "NamedEvalFamilyPlan", - )); - } source.push_str(&emit_point_value_constants(&self.point_values)); push_format( &mut source, @@ -74,8 +61,8 @@ impl Stage5InstructionReadRafEmitPlan { "pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan {{\n\ \x20 point: {},\n\ \x20 lookup_output_point: {},\n\ - \x20 table_flag_evals: &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS,\n\ - \x20 instruction_ra_evals: &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS,\n\ + \x20 table_flag_evals: {},\n\ + \x20 instruction_ra_evals: {},\n\ \x20 raf_flag_eval: {},\n\ \x20 gamma: {},\n\ \x20 point_values: STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES,\n\ @@ -83,6 +70,8 @@ impl Stage5InstructionReadRafEmitPlan { }};\n\n", rust_str(&self.point), rust_str(&self.lookup_output_point), + self.table_flag_evals_ref, + self.instruction_ra_evals_ref, rust_str(&self.raf_flag_eval), rust_str(&self.gamma), self.log_k, @@ -341,6 +330,10 @@ fn rust_str(value: &str) -> String { format!("{value:?}") } +fn indexed_eval_family_ref(index: usize) -> String { + format!("&{STAGE5_INDEXED_EVAL_FAMILIES_CONST}[{index}]") +} + #[cfg(test)] mod tests { use crate::emit::rust::EmitError; @@ -384,6 +377,36 @@ mod tests { plan.instruction_ra_evals.evals, vec!["stage5.instruction_read_raf.eval.InstructionRa_0"] ); + assert_eq!( + plan.table_flag_evals_ref, + "&STAGE5_INDEXED_EVAL_FAMILIES[0]" + ); + assert_eq!( + plan.instruction_ra_evals_ref, + "&STAGE5_INDEXED_EVAL_FAMILIES[1]" + ); + Ok(()) + } + + #[test] + fn instruction_read_raf_plan_references_indexed_eval_family_rows() -> Result<(), EmitError> { + let families = instruction_read_raf_families([ + ( + "LookupTableFlag_0", + "stage5.instruction_read_raf.eval.LookupTableFlag_0", + ), + ( + "InstructionRa_0", + "stage5.instruction_read_raf.eval.InstructionRa_0", + ), + ]); + let plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&families)?; + let source = plan.emit_runtime_constants(); + + assert!(!source.contains("STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS")); + assert!(!source.contains("STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS")); + assert!(source.contains("table_flag_evals: &STAGE5_INDEXED_EVAL_FAMILIES[0]")); + assert!(source.contains("instruction_ra_evals: &STAGE5_INDEXED_EVAL_FAMILIES[1]")); Ok(()) } diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index eb57d5e07d..62ec37ac93 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -1,4 +1,4 @@ -use crate::emit::rust::push_format; +use crate::emit::rust::{push_format, EmitError}; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_output_claims::{ SumcheckOutputClaimPlan, SumcheckOutputProductFamilyPlan, SumcheckOutputProductFamilyTermPlan, @@ -11,9 +11,6 @@ pub(crate) struct BytecodeReadRafPlan { pub(crate) const_name: &'static str, pub(crate) point: &'static str, pub(crate) gamma: &'static str, - pub(crate) bytecode_ra_eval_names_const: &'static str, - pub(crate) bytecode_ra_eval_family_const: &'static str, - pub(crate) bytecode_ra_eval_family_symbol: &'static str, pub(crate) entries: &'static str, pub(crate) entry_bytecode_index: &'static str, pub(crate) stages_const: &'static str, @@ -315,9 +312,6 @@ const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { const_name: "STAGE6_BYTECODE_PLAN", point: "stage6.bytecode_read_raf.point", gamma: "stage6.bytecode_read_raf.gamma", - bytecode_ra_eval_names_const: "STAGE6_BYTECODE_RA_EVAL_NAMES", - bytecode_ra_eval_family_const: "STAGE6_BYTECODE_RA_EVALS", - bytecode_ra_eval_family_symbol: STAGE6_BYTECODE_RA_EVAL_FAMILY, entries: "stage6.bytecode_read_raf.entries", entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", stages_const: "STAGE6_BYTECODE_STAGES", @@ -333,10 +327,8 @@ const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; -pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants( - bytecode_ra_evals: &IndexedEvalFamilyPlan, -) -> String { - emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN, bytecode_ra_evals) +pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants(bytecode_ra_evals_ref: &str) -> String { + emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN, bytecode_ra_evals_ref) } #[cfg(test)] @@ -377,19 +369,9 @@ impl BytecodeReadRafPlan { } } -fn emit_bytecode_read_raf_plan( - plan: &BytecodeReadRafPlan, - bytecode_ra_evals: &IndexedEvalFamilyPlan, -) -> String { +fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan, bytecode_ra_evals_ref: &str) -> String { let mut source = "\n".to_owned(); - source.push_str(&bytecode_ra_evals.emit_runtime_constant( - "", - plan.bytecode_ra_eval_names_const, - plan.bytecode_ra_eval_family_const, - "bolt_verifier_runtime::NamedEvalFamilyPlan", - )); - for stage in plan.stages { push_format( &mut source, @@ -456,7 +438,7 @@ fn emit_bytecode_read_raf_plan( " point: {},\n gamma: {},\n bytecode_ra_evals: &{},\n entries: {},\n entry_bytecode_index: {},\n stages: {},\n output_terms: {},\n output_contribution: {},\n", rust_str(plan.point), rust_str(plan.gamma), - plan.bytecode_ra_eval_family_const, + bytecode_ra_evals_ref, rust_str(plan.entries), rust_str(plan.entry_bytecode_index), plan.stages_const, @@ -486,6 +468,15 @@ fn emit_bytecode_read_raf_plan( source } +pub(crate) fn stage6_bytecode_read_raf_eval_family_ref<'a>( + eval_families: &'a [IndexedEvalFamilyPlan], + families_const: &str, +) -> Result<(String, &'a IndexedEvalFamilyPlan), EmitError> { + let (index, family) = + IndexedEvalFamilyPlan::find_with_index(eval_families, STAGE6_BYTECODE_RA_EVAL_FAMILY)?; + Ok((format!("{families_const}[{index}]"), family)) +} + fn emit_bytecode_read_raf_term_plan(term: &BytecodeReadRafTermPlan) -> String { match term { BytecodeReadRafTermPlan::Address { gamma_power } => { @@ -571,10 +562,12 @@ fn rust_option_str(value: Option<&str>) -> String { #[cfg(test)] mod tests { + use crate::emit::rust::EmitError; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use super::{ - emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_output_claim_plan, + emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, + stage6_bytecode_read_raf_output_claim_plan, stage6_bytecode_read_raf_output_contribution_symbol, BytecodeFlag, BytecodeOutputTermPlan, BytecodeReadRafTermPlan, BytecodeRegister, STAGE6_BYTECODE_RA_EVAL_FAMILY, STAGE6_BYTECODE_READ_RAF_PLAN, @@ -709,22 +702,31 @@ mod tests { #[test] fn stage6_bytecode_plan_renderer_emits_stage67_constants() { - let bytecode_ra_evals = bytecode_ra_evals(); - let source = emit_stage6_bytecode_read_raf_plan_constants(&bytecode_ra_evals); + let source = + emit_stage6_bytecode_read_raf_plan_constants("STAGE6_INDEXED_EVAL_FAMILIES[0]"); assert!(source.contains("const STAGE6_BYTECODE_STAGE1_TERMS")); assert!(source.contains("Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }")); assert!(source.contains("Stage67BytecodeFlag::IsInterleaved")); assert!(source.contains("Stage67BytecodeRegister::Rs2")); - assert!(source.contains("const STAGE6_BYTECODE_RA_EVAL_NAMES")); - assert!(source.contains("\"stage6.bytecode_read_raf.eval.BytecodeRa_3\"")); - assert!(source.contains( - "const STAGE6_BYTECODE_RA_EVALS: bolt_verifier_runtime::NamedEvalFamilyPlan" - )); + assert!(!source.contains("STAGE6_BYTECODE_RA_EVAL_NAMES")); + assert!(!source.contains("STAGE6_BYTECODE_RA_EVALS")); assert!(source.contains("const STAGE6_BYTECODE_OUTPUT_TERMS")); assert!(source.contains("Stage67BytecodeOutputTermPlan::Entry { gamma_power: 7 }")); assert!(source .contains("output_contribution: \"stage6.bytecode_read_raf.output.contribution\"")); + assert!(source.contains("bytecode_ra_evals: &STAGE6_INDEXED_EVAL_FAMILIES[0]")); assert!(source.contains("const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan")); } + + #[test] + fn stage6_bytecode_plan_references_indexed_eval_family_row() -> Result<(), EmitError> { + let families = [bytecode_ra_evals()]; + let (family_ref, family) = + stage6_bytecode_read_raf_eval_family_ref(&families, "STAGE6_INDEXED_EVAL_FAMILIES")?; + + assert_eq!(family_ref, "STAGE6_INDEXED_EVAL_FAMILIES[0]"); + assert_eq!(family.symbol, STAGE6_BYTECODE_RA_EVAL_FAMILY); + Ok(()) + } } diff --git a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs index 00c8fe0835..6e4d794900 100644 --- a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs +++ b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs @@ -11,44 +11,24 @@ impl IndexedEvalFamilyPlan { families: &'a [Self], symbol: &str, ) -> Result<&'a IndexedEvalFamilyPlan, EmitError> { - let mut matching_families = families.iter().filter(|family| family.symbol == symbol); - let family = matching_families + Self::find_with_index(families, symbol).map(|(_, family)| family) + } + + pub(crate) fn find_with_index<'a>( + families: &'a [Self], + symbol: &str, + ) -> Result<(usize, &'a IndexedEvalFamilyPlan), EmitError> { + let mut matching_families = families + .iter() + .enumerate() + .filter(|(_, family)| family.symbol == symbol); + let (index, family) = matching_families .next() .ok_or_else(|| EmitError::new(format!("missing eval family `{symbol}`")))?; if matching_families.next().is_some() { return Err(EmitError::new(format!("duplicate eval family `{symbol}`"))); } - Ok(family) - } - - pub(crate) fn emit_runtime_constant( - &self, - visibility: &str, - names_const: &str, - family_const: &str, - family_type: &str, - ) -> String { - let names_source = self - .evals - .iter() - .map(|name| rust_str(name)) - .collect::>() - .join(", "); - let mut source = String::new(); - push_format( - &mut source, - format_args!( - "#[rustfmt::skip]\n{visibility}const {names_const}: &[&str] = &[{names_source}];\n" - ), - ); - push_format( - &mut source, - format_args!( - "{visibility}const {family_const}: {family_type} = {family_type} {{ symbol: {}, evals: {names_const} }};\n\n", - rust_str(&self.symbol), - ), - ); - source + Ok((index, family)) } } @@ -127,6 +107,27 @@ mod tests { assert!(error.contains("duplicate eval family `stage.eval.BytecodeRa`")); } + #[test] + fn find_with_index_preserves_family_row_position() -> Result<(), crate::emit::rust::EmitError> { + let families = [ + IndexedEvalFamilyPlan { + symbol: "stage.eval.LookupTableFlag".to_owned(), + evals: vec!["stage.eval.LookupTableFlag_0".to_owned()], + }, + IndexedEvalFamilyPlan { + symbol: "stage.eval.BytecodeRa".to_owned(), + evals: vec!["stage.eval.BytecodeRa_0".to_owned()], + }, + ]; + + let (index, family) = + IndexedEvalFamilyPlan::find_with_index(&families, "stage.eval.BytecodeRa")?; + + assert_eq!(index, 1); + assert_eq!(family.symbol, "stage.eval.BytecodeRa"); + Ok(()) + } + #[test] fn emit_runtime_slice_constant_groups_eval_families() { let source = emit_runtime_slice_constant( diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 1a7e05e4cd..4b7e8eba35 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, find_batch, find_plan, NamedEvalFamilyPlan}; +use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; @@ -203,14 +203,6 @@ pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[ Stage5SumcheckEvalPlan { symbol: "stage5.registers_val_evaluation.eval.RdWa", source: "stage5.sumcheck", name: "stage5.registers_val_evaluation.eval.RdWa", index: 1, oracle: "RdWa" }, ]; -#[rustfmt::skip] -pub const STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVAL_NAMES: &[&str] = &["stage5.instruction_read_raf.eval.LookupTableFlag_0", "stage5.instruction_read_raf.eval.LookupTableFlag_1", "stage5.instruction_read_raf.eval.LookupTableFlag_2", "stage5.instruction_read_raf.eval.LookupTableFlag_3", "stage5.instruction_read_raf.eval.LookupTableFlag_4", "stage5.instruction_read_raf.eval.LookupTableFlag_5", "stage5.instruction_read_raf.eval.LookupTableFlag_6", "stage5.instruction_read_raf.eval.LookupTableFlag_7", "stage5.instruction_read_raf.eval.LookupTableFlag_8", "stage5.instruction_read_raf.eval.LookupTableFlag_9", "stage5.instruction_read_raf.eval.LookupTableFlag_10", "stage5.instruction_read_raf.eval.LookupTableFlag_11", "stage5.instruction_read_raf.eval.LookupTableFlag_12", "stage5.instruction_read_raf.eval.LookupTableFlag_13", "stage5.instruction_read_raf.eval.LookupTableFlag_14", "stage5.instruction_read_raf.eval.LookupTableFlag_15", "stage5.instruction_read_raf.eval.LookupTableFlag_16", "stage5.instruction_read_raf.eval.LookupTableFlag_17", "stage5.instruction_read_raf.eval.LookupTableFlag_18", "stage5.instruction_read_raf.eval.LookupTableFlag_19", "stage5.instruction_read_raf.eval.LookupTableFlag_20", "stage5.instruction_read_raf.eval.LookupTableFlag_21", "stage5.instruction_read_raf.eval.LookupTableFlag_22", "stage5.instruction_read_raf.eval.LookupTableFlag_23", "stage5.instruction_read_raf.eval.LookupTableFlag_24", "stage5.instruction_read_raf.eval.LookupTableFlag_25", "stage5.instruction_read_raf.eval.LookupTableFlag_26", "stage5.instruction_read_raf.eval.LookupTableFlag_27", "stage5.instruction_read_raf.eval.LookupTableFlag_28", "stage5.instruction_read_raf.eval.LookupTableFlag_29", "stage5.instruction_read_raf.eval.LookupTableFlag_30", "stage5.instruction_read_raf.eval.LookupTableFlag_31", "stage5.instruction_read_raf.eval.LookupTableFlag_32", "stage5.instruction_read_raf.eval.LookupTableFlag_33", "stage5.instruction_read_raf.eval.LookupTableFlag_34", "stage5.instruction_read_raf.eval.LookupTableFlag_35", "stage5.instruction_read_raf.eval.LookupTableFlag_36", "stage5.instruction_read_raf.eval.LookupTableFlag_37", "stage5.instruction_read_raf.eval.LookupTableFlag_38", "stage5.instruction_read_raf.eval.LookupTableFlag_39", "stage5.instruction_read_raf.eval.LookupTableFlag_40"]; -pub const STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS: NamedEvalFamilyPlan = NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.LookupTableFlag", evals: STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVAL_NAMES }; - -#[rustfmt::skip] -pub const STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES: &[&str] = &["stage5.instruction_read_raf.eval.InstructionRa_0", "stage5.instruction_read_raf.eval.InstructionRa_1", "stage5.instruction_read_raf.eval.InstructionRa_2", "stage5.instruction_read_raf.eval.InstructionRa_3", "stage5.instruction_read_raf.eval.InstructionRa_4", "stage5.instruction_read_raf.eval.InstructionRa_5", "stage5.instruction_read_raf.eval.InstructionRa_6", "stage5.instruction_read_raf.eval.InstructionRa_7"]; -pub const STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS: NamedEvalFamilyPlan = NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.InstructionRa", evals: STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVAL_NAMES }; - pub const STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES: &[Stage5InstructionReadRafPointValuePlan] = &[ Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_0", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 0 } }, Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_1", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 1 } }, @@ -261,8 +253,8 @@ pub const STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES: &[Stage5InstructionReadRafPo pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan { point: "stage5.instruction_read_raf.point", lookup_output_point: "stage5.input.stage2.instruction.LookupOutput", - table_flag_evals: &STAGE5_INSTRUCTION_READ_RAF_TABLE_FLAG_EVALS, - instruction_ra_evals: &STAGE5_INSTRUCTION_READ_RAF_INSTRUCTION_RA_EVALS, + table_flag_evals: &STAGE5_INDEXED_EVAL_FAMILIES[0], + instruction_ra_evals: &STAGE5_INDEXED_EVAL_FAMILIES[1], raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag", gamma: "stage5.instruction_read_raf.gamma", point_values: STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 2c53c29c2f..af95e4e478 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -555,10 +555,6 @@ pub const STAGE6_INDEXED_EVAL_FAMILIES: &[bolt_verifier_runtime::NamedEvalFamily ]; -#[rustfmt::skip] -const STAGE6_BYTECODE_RA_EVAL_NAMES: &[&str] = &["stage6.bytecode_read_raf.eval.BytecodeRa_0", "stage6.bytecode_read_raf.eval.BytecodeRa_1", "stage6.bytecode_read_raf.eval.BytecodeRa_2"]; -const STAGE6_BYTECODE_RA_EVALS: bolt_verifier_runtime::NamedEvalFamilyPlan = bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage6.bytecode_read_raf.eval.BytecodeRa", evals: STAGE6_BYTECODE_RA_EVAL_NAMES }; - const STAGE6_BYTECODE_STAGE1_TERMS: &[Stage67BytecodeTermPlan] = &[ Stage67BytecodeTermPlan::Address { gamma_power: 0 }, Stage67BytecodeTermPlan::Imm { gamma_power: 1 }, @@ -624,7 +620,7 @@ const STAGE6_BYTECODE_OUTPUT_TERMS: &[Stage67BytecodeOutputTermPlan] = &[ const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { point: "stage6.bytecode_read_raf.point", gamma: "stage6.bytecode_read_raf.gamma", - bytecode_ra_evals: &STAGE6_BYTECODE_RA_EVALS, + bytecode_ra_evals: &STAGE6_INDEXED_EVAL_FAMILIES[0], entries: "stage6.bytecode_read_raf.entries", entry_bytecode_index: "stage6.bytecode_read_raf.entry_bytecode_index", stages: STAGE6_BYTECODE_STAGES, From 58162966cf9fd139a5cb82023250705938d9c334 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 18:53:45 -0600 Subject: [PATCH 095/171] refactor(bolt): name expected outputs --- crates/bolt-verifier-runtime/src/lib.rs | 6 +++--- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 4 +++- .../protocols/jolt/emit/rust/output_claims.rs | 4 ++-- .../src/protocols/jolt/emit/rust/stage3.rs | 4 ++-- .../src/protocols/jolt/emit/rust/stage4.rs | 4 ++-- .../src/protocols/jolt/emit/rust/stage5.rs | 4 ++-- .../src/protocols/jolt/emit/rust/stage6.rs | 4 ++-- .../src/protocols/jolt/emit/rust/stage7.rs | 4 ++-- .../jolt/stage5_instruction_read_raf_plan.rs | 4 ++-- .../jolt/stage6_bytecode_read_raf_plan.rs | 4 ++-- .../protocols/jolt/verifier_output_claims.rs | 20 +++++++++---------- crates/bolt/tests/commitment_ir.rs | 12 +++++------ crates/jolt-equivalence/src/plan_adapters.rs | 2 +- crates/jolt-verifier/src/stages/stage3.rs | 6 +++--- crates/jolt-verifier/src/stages/stage4.rs | 4 ++-- crates/jolt-verifier/src/stages/stage5.rs | 6 +++--- crates/jolt-verifier/src/stages/stage6.rs | 12 +++++------ crates/jolt-verifier/src/stages/stage7.rs | 2 +- 18 files changed, 54 insertions(+), 52 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 48057eb8d1..b1b1246135 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -444,7 +444,7 @@ pub struct SumcheckOutputClaimPlan { pub product_families: &'static [SumcheckOutputProductFamilyPlan], pub function_families: &'static [SumcheckOutputFunctionFamilyPlan], pub local_scalars: &'static [&'static str], - pub claim_value: &'static str, + pub expected_output: &'static str, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -1359,9 +1359,9 @@ pub fn evaluate_sumcheck_output_claim( } evaluate_available_field_exprs_with_scratch(field_exprs, store, &mut scratch)?; scratch - .scalar_or(store, plan.claim_value) + .scalar_or(store, plan.expected_output) .ok_or(RuntimePlanError::MissingValue { - symbol: plan.claim_value, + symbol: plan.expected_output, }) } diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 33f0c0eeb9..302ed3b338 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -595,7 +595,9 @@ an eval-family vector by symbol, and Stage 5 instruction RA / Stage 6 bytecode RA products use that path. The Stage 5 instruction read-RAF and Stage 6 bytecode read-RAF relation plans now reference the same plan-level `STAGE*_INDEXED_EVAL_FAMILIES` rows instead of emitting duplicate -relation-local `NamedEvalFamilyPlan` constants. Output eval families are still +relation-local `NamedEvalFamilyPlan` constants. Output relation rows now name +their terminal scalar `expected_output`, keeping verifier expected-output data +separate from input sumcheck `claim_value` data. Output eval families are still scalar-output claim machinery rather than first-class value rows. ### Dialect changes diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs index 4706457d08..e302c3b5e1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs @@ -44,9 +44,9 @@ pub fn emit_verifier_output_claim_constants( emit_function_family_constants(&mut source, stage_type, index, claim)?; let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim); claims.push(format!( - " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, product_families: {product_families}, function_families: {function_families}, local_scalars: {local_scalars}, claim_value: {} }},", + " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, product_families: {product_families}, function_families: {function_families}, local_scalars: {local_scalars}, expected_output: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, - rust_str(&claim.claim_value) + rust_str(&claim.expected_output) )); } let claims = claims.join("\n"); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index b4feca8306..66fb33966d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -512,7 +512,7 @@ impl Stage3CpuProgram { "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage3SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, - claim_value: operand_symbol(op, 0)?, + expected_output: operand_symbol(op, 0)?, polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, polynomial_eval_operands: operand_symbols(op, 1)?, }); @@ -578,7 +578,7 @@ impl Stage3CpuProgram { claims.iter().map(|claim| claim.claim_value.as_str()), output_claim_asts .iter() - .map(|claim| claim.claim_value.as_str()), + .map(|claim| claim.expected_output.as_str()), ); } let output_claims = if role == Role::Verifier { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 4586e56ec5..ab78ad349d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -524,7 +524,7 @@ impl Stage4CpuProgram { "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage4SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, - claim_value: operand_symbol(op, 0)?, + expected_output: operand_symbol(op, 0)?, polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, polynomial_eval_operands: operand_symbols(op, 1)?, }); @@ -590,7 +590,7 @@ impl Stage4CpuProgram { claims.iter().map(|claim| claim.claim_value.as_str()), output_claim_asts .iter() - .map(|claim| claim.claim_value.as_str()), + .map(|claim| claim.expected_output.as_str()), ); } let output_claims = if role == Role::Verifier { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 31ebc6a545..df62905f6d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -566,7 +566,7 @@ impl Stage5CpuProgram { "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage5SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, - claim_value: operand_symbol(op, 0)?, + expected_output: operand_symbol(op, 0)?, polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, polynomial_eval_operands: operand_symbols(op, 1)?, }); @@ -632,7 +632,7 @@ impl Stage5CpuProgram { claims.iter().map(|claim| claim.claim_value.as_str()), output_claim_asts .iter() - .map(|claim| claim.claim_value.as_str()), + .map(|claim| claim.expected_output.as_str()), ); } let mut output_claims = if role == Role::Verifier { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index e2515182b3..d289e5b875 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -594,7 +594,7 @@ impl Stage6CpuProgram { "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage6SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, - claim_value: operand_symbol(op, 0)?, + expected_output: operand_symbol(op, 0)?, polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, polynomial_eval_operands: operand_symbols(op, 1)?, }); @@ -667,7 +667,7 @@ impl Stage6CpuProgram { claims.iter().map(|claim| claim.claim_value.as_str()), output_claim_asts .iter() - .map(|claim| claim.claim_value.as_str()), + .map(|claim| claim.expected_output.as_str()), ); } let mut output_claims = if role == Role::Verifier { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 80dca1395c..ea775079a7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -569,7 +569,7 @@ impl Stage7CpuProgram { "cpu.sumcheck_output_claim" => { output_claim_asts.push(Stage7SumcheckOutputClaimAst { relation: symbol_attr(op, "relation")?, - claim_value: operand_symbol(op, 0)?, + expected_output: operand_symbol(op, 0)?, polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, polynomial_eval_operands: operand_symbols(op, 1)?, }); @@ -642,7 +642,7 @@ impl Stage7CpuProgram { claims.iter().map(|claim| claim.claim_value.as_str()), output_claim_asts .iter() - .map(|claim| claim.claim_value.as_str()), + .map(|claim| claim.expected_output.as_str()), ); } let output_claims = if role == Role::Verifier { diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index bdf9322b9e..9f19c40965 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -214,7 +214,7 @@ impl Stage5InstructionReadRafEmitPlan { .iter() .map(|value| value.symbol.clone()) .collect(), - claim_value: claim_expr, + expected_output: claim_expr, }, } } @@ -434,7 +434,7 @@ mod tests { "jolt.stage5.instruction_read_raf" ); assert_eq!( - output_plan.claim.claim_value, + output_plan.claim.expected_output, "stage5.instruction_read_raf.output.claim_expr" ); assert_eq!(output_plan.claim.polynomial_evals.len(), 1); diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 62ec37ac93..fb86e6c2b5 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -364,7 +364,7 @@ impl BytecodeReadRafPlan { product_families: vec![product_family.clone()], function_families: Vec::new(), local_scalars: vec![self.output_contribution.to_owned()], - claim_value: product_family.symbol, + expected_output: product_family.symbol, } } } @@ -679,7 +679,7 @@ mod tests { assert_eq!(claim.relation, "jolt.stage6.bytecode_read_raf"); assert_eq!( - claim.claim_value, + claim.expected_output, "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" ); assert!(claim.polynomial_evals.is_empty()); diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs index 52453ab939..e4f8a14c69 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_output_claims.rs @@ -254,7 +254,7 @@ pub struct SumcheckOutputClaimPlan { pub product_families: Vec, pub function_families: Vec, pub local_scalars: Vec, - pub claim_value: String, + pub expected_output: String, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -262,7 +262,7 @@ pub struct SumcheckOutputClaimAst { pub relation: String, pub polynomial_evals: Vec, pub polynomial_eval_operands: Vec, - pub claim_value: String, + pub expected_output: String, } pub fn parse_output_eval_family_plan( @@ -583,7 +583,7 @@ where &output_product_families_by_symbol, &output_function_families_by_symbol, &field_exprs_by_symbol, - std::iter::once(claim.claim_value.as_str()), + std::iter::once(claim.expected_output.as_str()), ); let eval_families = output_families .iter() @@ -607,7 +607,7 @@ where product_families, function_families, local_scalars: Vec::new(), - claim_value: claim.claim_value, + expected_output: claim.expected_output, }) }) .collect() @@ -1007,10 +1007,10 @@ pub fn verify_output_claims( claim.relation ))); } - if !field_values.contains(&claim.claim_value) { + if !field_values.contains(&claim.expected_output) { return Err(EmitError::new(format!( - "{stage} output claim for @{} uses missing claim value @{}", - claim.relation, claim.claim_value + "{stage} output claim for @{} uses missing expected output @{}", + claim.relation, claim.expected_output ))); } } @@ -1271,7 +1271,7 @@ mod tests { relation: "relation".to_owned(), polynomial_evals: Vec::new(), polynomial_eval_operands: Vec::new(), - claim_value: "claim.expr".to_owned(), + expected_output: "claim.expr".to_owned(), }]; let claims = resolve_output_claims( @@ -1323,7 +1323,7 @@ mod tests { relation: "relation".to_owned(), polynomial_evals: Vec::new(), polynomial_eval_operands: Vec::new(), - claim_value: "claim.expr".to_owned(), + expected_output: "claim.expr".to_owned(), }]; let claims = resolve_output_claims( @@ -1375,7 +1375,7 @@ mod tests { relation: "relation".to_owned(), polynomial_evals: Vec::new(), polynomial_eval_operands: Vec::new(), - claim_value: "claim.expr".to_owned(), + expected_output: "claim.expr".to_owned(), }]; let claims = resolve_output_claims( diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index cd4f6ef5af..2e59e34293 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1705,7 +1705,7 @@ fn stage6_rust_targets_extract_and_compile() { let inc_claims = verifier_program .output_claims .iter() - .filter(|claim| claim.claim_value == "stage6.inc_claim_reduction.output.family") + .filter(|claim| claim.expected_output == "stage6.inc_claim_reduction.output.family") .collect::>(); assert_eq!(inc_claims.len(), 1); assert_eq!(inc_claims[0].eval_families, vec![inc_family.clone()]); @@ -1714,7 +1714,7 @@ fn stage6_rust_targets_extract_and_compile() { let booleanity_claims = verifier_program .output_claims .iter() - .filter(|claim| claim.claim_value == "stage6.booleanity.output.family") + .filter(|claim| claim.expected_output == "stage6.booleanity.output.family") .collect::>(); assert_eq!(booleanity_claims.len(), 1); assert!(booleanity_claims[0].eval_families.is_empty()); @@ -1730,7 +1730,7 @@ fn stage6_rust_targets_extract_and_compile() { let hamming_claims = verifier_program .output_claims .iter() - .filter(|claim| claim.claim_value == "stage6.hamming_booleanity.output.family") + .filter(|claim| claim.expected_output == "stage6.hamming_booleanity.output.family") .collect::>(); assert_eq!(hamming_claims.len(), 1); assert!(hamming_claims[0].eval_families.is_empty()); @@ -1742,7 +1742,7 @@ fn stage6_rust_targets_extract_and_compile() { let ram_ra_claims = verifier_program .output_claims .iter() - .filter(|claim| claim.claim_value == "stage6.ram_ra_virtual.output.family") + .filter(|claim| claim.expected_output == "stage6.ram_ra_virtual.output.family") .collect::>(); assert_eq!(ram_ra_claims.len(), 1); assert!(ram_ra_claims[0].eval_families.is_empty()); @@ -1754,7 +1754,7 @@ fn stage6_rust_targets_extract_and_compile() { let instruction_ra_claims = verifier_program .output_claims .iter() - .filter(|claim| claim.claim_value == "stage6.instruction_ra_virtual.output.family") + .filter(|claim| claim.expected_output == "stage6.instruction_ra_virtual.output.family") .collect::>(); assert_eq!(instruction_ra_claims.len(), 1); assert!(instruction_ra_claims[0].eval_families.is_empty()); @@ -1767,7 +1767,7 @@ fn stage6_rust_targets_extract_and_compile() { .output_claims .iter() .filter(|claim| { - claim.claim_value == "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" + claim.expected_output == "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }) .collect::>(); assert_eq!(bytecode_claims.len(), 1); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index ced510a987..d7138b09a8 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -759,7 +759,7 @@ macro_rules! define_stage_adapter_impl { .collect(), ), local_scalars: super::leak_str_slice(&plan.local_scalars), - claim_value: super::leak_str(&plan.claim_value), + expected_output: super::leak_str(&plan.expected_output), }) .collect(), ), diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 1ff67da743..e41643a26a 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -224,9 +224,9 @@ pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage3StructuredPolynomialEva ]; pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[ - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage3.spartan_shift.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage3.instruction_input.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage3.registers.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, + Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 5a18ef1b1c..0f702236b7 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -183,8 +183,8 @@ pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage4StructuredPolynomialEva ]; pub const STAGE4_SUMCHECK_OUTPUT_CLAIMS: &[Stage4SumcheckOutputClaimPlan] = &[ - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage4.registers_read_write.output.claim_expr" }, - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage4.ram_val_check.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, + Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 4b7e8eba35..34659bbd9f 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -426,9 +426,9 @@ pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runti pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; pub const STAGE5_SUMCHECK_OUTPUT_CLAIMS: &[Stage5SumcheckOutputClaimPlan] = &[ - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage5.registers_val_evaluation.output.claim_expr" }, - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_LOCAL_SCALARS, claim_value: "stage5.instruction_read_raf.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index af95e4e478..8d43531242 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -754,12 +754,12 @@ pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES: &[bolt_verifier_runti pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[ - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6Booleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES, local_scalars: &[], claim_value: "stage6.booleanity.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILIES, local_scalars: &[], claim_value: "stage6.hamming_booleanity.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], claim_value: "stage6.ram_ra_virtual.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], claim_value: "stage6.instruction_ra_virtual.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage6.inc_claim_reduction.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_LOCAL_SCALARS, claim_value: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6Booleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.family" }, + Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 5a2671aceb..4ad4b7151f 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -285,7 +285,7 @@ pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES: &[bolt_verifier_runtime::Sumc ]; pub const STAGE7_SUMCHECK_OUTPUT_CLAIMS: &[Stage7SumcheckOutputClaimPlan] = &[ - Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], claim_value: "stage7.hamming_weight_claim_reduction.output.family" }, + Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.family" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ From d264524685ed552dbd05b4a9c59c8f6062a20d55 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 19:07:25 -0600 Subject: [PATCH 096/171] refactor(bolt): rename relation output plans --- crates/bolt-verifier-runtime/src/lib.rs | 104 ++--- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 37 +- .../bolt/src/protocols/jolt/emit/rust/mod.rs | 2 +- .../{output_claims.rs => relation_outputs.rs} | 89 ++-- .../src/protocols/jolt/emit/rust/stage3.rs | 75 ++-- .../src/protocols/jolt/emit/rust/stage4.rs | 79 ++-- .../src/protocols/jolt/emit/rust/stage5.rs | 149 ++++--- .../src/protocols/jolt/emit/rust/stage6.rs | 151 ++++--- .../src/protocols/jolt/emit/rust/stage7.rs | 131 +++--- crates/bolt/src/protocols/jolt/mod.rs | 2 +- .../jolt/stage5_instruction_read_raf_plan.rs | 24 +- .../jolt/stage6_bytecode_read_raf_plan.rs | 28 +- .../bolt/src/protocols/jolt/verifier_plan.rs | 102 +++-- ...claims.rs => verifier_relation_outputs.rs} | 422 +++++++++--------- crates/bolt/tests/commitment_ir.rs | 92 ++-- crates/jolt-equivalence/src/plan_adapters.rs | 54 +-- .../src/plan_adapters/generated_stage3.rs | 4 +- .../src/plan_adapters/generated_stage4.rs | 4 +- .../src/plan_adapters/generated_stage5.rs | 4 +- .../src/plan_adapters/generated_stage6.rs | 4 +- .../src/plan_adapters/generated_stage7.rs | 4 +- crates/jolt-verifier/src/stages/stage3.rs | 22 +- crates/jolt-verifier/src/stages/stage4.rs | 18 +- crates/jolt-verifier/src/stages/stage5.rs | 122 ++--- crates/jolt-verifier/src/stages/stage6.rs | 186 ++++---- crates/jolt-verifier/src/stages/stage7.rs | 30 +- 26 files changed, 983 insertions(+), 956 deletions(-) rename crates/bolt/src/protocols/jolt/emit/rust/{output_claims.rs => relation_outputs.rs} (79%) rename crates/bolt/src/protocols/jolt/{verifier_output_claims.rs => verifier_relation_outputs.rs} (74%) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index b1b1246135..75eddf87de 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -379,30 +379,30 @@ pub struct StructuredPolynomialEvalPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckOutputEvalFamilySharedTermPlan { +pub struct RelationOutputEvalFamilySharedTermPlan { pub gamma_power_offset: usize, pub factor: &'static str, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckOutputEvalFamilyItemTermPlan { +pub struct RelationOutputEvalFamilyItemTermPlan { pub gamma_power_offset: usize, pub factors: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckOutputEvalFamilyPlan { +pub struct RelationOutputEvalFamilyPlan { pub symbol: &'static str, pub gamma: &'static str, pub evals: &'static [&'static str], pub power_stride: usize, pub value_term_offsets: &'static [usize], - pub shared_terms: &'static [SumcheckOutputEvalFamilySharedTermPlan], - pub item_terms: &'static [SumcheckOutputEvalFamilyItemTermPlan], + pub shared_terms: &'static [RelationOutputEvalFamilySharedTermPlan], + pub item_terms: &'static [RelationOutputEvalFamilyItemTermPlan], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckOutputProductFamilyTermPlan { +pub struct RelationOutputProductFamilyTermPlan { pub gamma_power_offset: usize, pub evals: &'static [&'static str], pub eval_families: &'static [&'static str], @@ -410,39 +410,39 @@ pub struct SumcheckOutputProductFamilyTermPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckOutputProductFamilyPlan { +pub struct RelationOutputProductFamilyPlan { pub symbol: &'static str, pub gamma: Option<&'static str>, - pub terms: &'static [SumcheckOutputProductFamilyTermPlan], + pub terms: &'static [RelationOutputProductFamilyTermPlan], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum SumcheckOutputFunctionKind { +pub enum RelationOutputFunctionKind { BooleanZero, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckOutputFunctionFamilyTermPlan { +pub struct RelationOutputFunctionFamilyTermPlan { pub gamma_power_offset: usize, - pub function: SumcheckOutputFunctionKind, + pub function: RelationOutputFunctionKind, pub eval: &'static str, pub factors: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckOutputFunctionFamilyPlan { +pub struct RelationOutputFunctionFamilyPlan { pub symbol: &'static str, pub gamma: Option<&'static str>, - pub terms: &'static [SumcheckOutputFunctionFamilyTermPlan], + pub terms: &'static [RelationOutputFunctionFamilyTermPlan], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct SumcheckOutputClaimPlan { +pub struct RelationOutputPlan { pub relation: R, pub polynomial_evals: &'static [StructuredPolynomialEvalPlan], - pub eval_families: &'static [SumcheckOutputEvalFamilyPlan], - pub product_families: &'static [SumcheckOutputProductFamilyPlan], - pub function_families: &'static [SumcheckOutputFunctionFamilyPlan], + pub eval_families: &'static [RelationOutputEvalFamilyPlan], + pub product_families: &'static [RelationOutputProductFamilyPlan], + pub function_families: &'static [RelationOutputFunctionFamilyPlan], pub local_scalars: &'static [&'static str], pub expected_output: &'static str, } @@ -531,7 +531,7 @@ pub struct StageProgramPlan { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], - pub output_claims: &'static [SumcheckOutputClaimPlan], + pub relation_outputs: &'static [RelationOutputPlan], pub point_zeros: &'static [PointZeroPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], @@ -556,7 +556,7 @@ pub struct StageProgramPlanNoPointZeros { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], - pub output_claims: &'static [SumcheckOutputClaimPlan], + pub relation_outputs: &'static [RelationOutputPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], pub opening_claims: &'static [OpeningClaimPlan], @@ -577,7 +577,7 @@ pub struct StageVerifierProgramPlan { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], - pub output_claims: &'static [SumcheckOutputClaimPlan], + pub relation_outputs: &'static [RelationOutputPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], pub opening_claims: &'static [OpeningClaimPlan], @@ -1297,8 +1297,8 @@ pub fn eval_family_values( .collect() } -pub fn evaluate_sumcheck_output_claim( - plan: &SumcheckOutputClaimPlan, +pub fn evaluate_relation_output( + plan: &RelationOutputPlan, field_exprs: &[FieldExprPlan], store: &ValueStore, instance_symbol: &'static str, @@ -1320,7 +1320,7 @@ pub fn evaluate_sumcheck_output_claim( scratch.insert(eval.name, eval.value); } for polynomial_eval in plan.polynomial_evals { - let x_raw_point = output_claim_x_point_source( + let x_raw_point = relation_output_x_point_source( polynomial_eval.x_point.source, instance_symbol, local_points, @@ -1346,15 +1346,15 @@ pub fn evaluate_sumcheck_output_claim( scratch.insert(polynomial_eval.symbol, value); } for family in plan.eval_families { - let value = evaluate_sumcheck_output_eval_family(family, store, &scratch)?; + let value = evaluate_relation_output_eval_family(family, store, &scratch)?; scratch.insert(family.symbol, value); } for family in plan.function_families { - let value = evaluate_sumcheck_output_function_family(family, store, &scratch)?; + let value = evaluate_relation_output_function_family(family, store, &scratch)?; scratch.insert(family.symbol, value); } for family in plan.product_families { - let value = evaluate_sumcheck_output_product_family(family, store, &scratch)?; + let value = evaluate_relation_output_product_family(family, store, &scratch)?; scratch.insert(family.symbol, value); } evaluate_available_field_exprs_with_scratch(field_exprs, store, &mut scratch)?; @@ -1365,8 +1365,8 @@ pub fn evaluate_sumcheck_output_claim( }) } -pub fn evaluate_sumcheck_instance_output_claim( - output_claims: &[SumcheckOutputClaimPlan], +pub fn evaluate_relation_output_for_instance( + relation_outputs: &[RelationOutputPlan], field_exprs: &[FieldExprPlan], store: &ValueStore, instance: &SumcheckInstanceResultPlan, @@ -1375,15 +1375,15 @@ pub fn evaluate_sumcheck_instance_output_claim( local_points: &[NamedPoint<'_, Fr>], local_point: &[Fr], ) -> Result { - let output_claim = output_claims + let relation_output = relation_outputs .iter() - .find(|output_claim| output_claim.relation == instance.relation) + .find(|relation_output| relation_output.relation == instance.relation) .ok_or(RuntimePlanError::InvalidProof { driver: instance.symbol, - reason: "missing output claim for relation", + reason: "missing relation output for relation", })?; - evaluate_sumcheck_output_claim( - output_claim, + evaluate_relation_output( + relation_output, field_exprs, store, instance.symbol, @@ -1394,7 +1394,7 @@ pub fn evaluate_sumcheck_instance_output_claim( ) } -fn output_claim_x_point_source<'a>( +fn relation_output_x_point_source<'a>( source: &'static str, instance_symbol: &'static str, local_points: &'a [NamedPoint<'a, Fr>], @@ -1410,8 +1410,8 @@ fn output_claim_x_point_source<'a>( .ok_or(RuntimePlanError::MissingValue { symbol: source }) } -fn evaluate_sumcheck_output_eval_family( - family: &SumcheckOutputEvalFamilyPlan, +fn evaluate_relation_output_eval_family( + family: &RelationOutputEvalFamilyPlan, store: &ValueStore, scratch: &ScratchScalars, ) -> Result { @@ -1476,12 +1476,12 @@ fn evaluate_sumcheck_output_eval_family( Ok(result) } -fn evaluate_sumcheck_output_product_family( - family: &SumcheckOutputProductFamilyPlan, +fn evaluate_relation_output_product_family( + family: &RelationOutputProductFamilyPlan, store: &ValueStore, scratch: &ScratchScalars, ) -> Result { - let gamma = output_family_gamma(family.gamma, store, scratch)?; + let gamma = relation_output_family_gamma(family.gamma, store, scratch)?; let mut result = Fr::from_u64(0); for term in family.terms { if term.evals.is_empty() && term.eval_families.is_empty() && term.factors.is_empty() { @@ -1518,19 +1518,19 @@ fn evaluate_sumcheck_output_product_family( Ok(result) } -fn evaluate_sumcheck_output_function_family( - family: &SumcheckOutputFunctionFamilyPlan, +fn evaluate_relation_output_function_family( + family: &RelationOutputFunctionFamilyPlan, store: &ValueStore, scratch: &ScratchScalars, ) -> Result { - let gamma = output_family_gamma(family.gamma, store, scratch)?; + let gamma = relation_output_family_gamma(family.gamma, store, scratch)?; let mut result = Fr::from_u64(0); for term in family.terms { let eval = scratch .scalar_or(store, term.eval) .ok_or(RuntimePlanError::MissingValue { symbol: term.eval })?; let mut product = pow_field(gamma, term.gamma_power_offset) - * evaluate_output_function(term.function, eval); + * evaluate_relation_output_function(term.function, eval); for &symbol in term.factors { let value = scratch .scalar_or(store, symbol) @@ -1542,13 +1542,13 @@ fn evaluate_sumcheck_output_function_family( Ok(result) } -fn evaluate_output_function(function: SumcheckOutputFunctionKind, eval: Fr) -> Fr { +fn evaluate_relation_output_function(function: RelationOutputFunctionKind, eval: Fr) -> Fr { match function { - SumcheckOutputFunctionKind::BooleanZero => eval * eval - eval, + RelationOutputFunctionKind::BooleanZero => eval * eval - eval, } } -fn output_family_gamma( +fn relation_output_family_gamma( gamma: Option<&'static str>, store: &ValueStore, scratch: &ScratchScalars, @@ -1866,9 +1866,9 @@ pub fn reverse_slice(values: &[Fr]) -> Vec { )] mod tests { use super::{ - evaluate_sumcheck_output_product_family, Fr, NamedEvalFamilyPlan, RuntimePlanError, - ScratchScalars, SumcheckOutputProductFamilyPlan, SumcheckOutputProductFamilyTermPlan, - ValueStore, + evaluate_relation_output_product_family, Fr, NamedEvalFamilyPlan, + RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, RuntimePlanError, + ScratchScalars, ValueStore, }; #[test] @@ -1914,11 +1914,11 @@ mod tests { store.insert_scalar("scalar.factor", Fr::from_u64(5)); store.insert_field_vector("family.ab", vec![Fr::from_u64(2), Fr::from_u64(3)]); - let value = evaluate_sumcheck_output_product_family( - &SumcheckOutputProductFamilyPlan { + let value = evaluate_relation_output_product_family( + &RelationOutputProductFamilyPlan { symbol: "product.family", gamma: None, - terms: &[SumcheckOutputProductFamilyTermPlan { + terms: &[RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["scalar.factor"], eval_families: &["family.ab"], diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 302ed3b338..12eba9c875 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -29,7 +29,7 @@ The current stack has already moved beyond the original S1 framing: - Generated stages use typed relation enums instead of relation `&'static str` dispatch. - The top-level verifier executes a typed verifier-program plan. -- Structured output-claim and polynomial-eval plans have started replacing +- Structured relation-output and polynomial-eval plans have started replacing handwritten verifier math. The remaining plan is therefore **pass-first, runtime-second**. The primary @@ -140,11 +140,11 @@ pub enum VerifierStepPlan { ``` `SumcheckDriverPlan` is the central verifier concept. It should contain the -proof slot, round schedule, input-claim plan, batching plan, output-claim -emission, value/eval observation, expected-output scalar, and opening-claim -emission for one sumcheck driver. Planning passes should assemble this shape -before Rust emission. The runtime should not need to rediscover whether a driver -came from "Stage 3" or "Stage 6" except for diagnostics and proof-record layout. +proof slot, round schedule, input-claim plan, batching plan, relation-output +plan, value/eval observation, expected-output scalar, and opening-claim emission +for one sumcheck driver. Planning passes should assemble this shape before Rust +emission. The runtime should not need to rediscover whether a driver came from +"Stage 3" or "Stage 6" except for diagnostics and proof-record layout. Commitment receipt and PCS opening verification are first-class verifier steps, not synthetic stages. Partial verification targets should eventually be named @@ -184,7 +184,7 @@ an explicit decision, or weaker semantically. | Slice | Tier A | Tier B | Tier C | jolt-verifier total | Notes | |-------|-------:|-------:|-------:|--------------------:|-------| | post-S1 (today) | 1,265 | 638 | 6,430 | 7,905 | hard ceilings: A 1,400 / B 700 / C surface 6,100 | -| current stack | ~0 in generated crate | <=700 | bounded by cleanup gates | bounded by cleanup gates | runtime extraction, typed relations, top-level verifier program, output-claim plans | +| current stack | ~0 in generated crate | <=700 | bounded by cleanup gates | bounded by cleanup gates | runtime extraction, typed relations, top-level verifier program, relation-output plans | | next pass-first slice | narrow runtime | <=700 | stable or lower | stable or lower | classify runtime/codegen/poly ownership and add planning-pass seams | | value graph | narrow runtime | <=638 | ~6,300-6,500 | ~6,500 | typed scalar/point/vector/eval-family plans | | eval families | narrow runtime | ~350 | ~6,500 | ~6,500 | typed indexed-eval addressing | @@ -526,7 +526,7 @@ emitter or `bolt-verifier-runtime` responsible for discovering verifier semantics. The current `cpu` layer still carries protocol-plan material such as stages, -proof slots, relation symbols, opening sources, point order, output claims, and +proof slots, relation symbols, opening sources, point order, relation outputs, and PCS policies. That is acceptable as a transitional representation, but the Rust emitter should not parse those fields into execution meaning. It should consume a typed Rust-plan / verifier-plan representation produced by passes. @@ -540,8 +540,8 @@ consume a typed Rust-plan / verifier-plan representation produced by passes. verifier data requirements, and kernel ABI where relevant. 3. `plan-verifier-sumchecks`: lower verifier sumcheck ops plus batches and instance results into `SumcheckDriverPlan` rows. -4. `plan-field-and-output-claims`: canonicalize field expressions, structured - polynomial evals, and output-claim equations into a typed scalar/point/value +4. `plan-field-and-relation-outputs`: canonicalize field expressions, structured + polynomial evals, and relation-output equations into a typed scalar/point/value graph. 5. `plan-opening-flow`: resolve opening inputs, claims, equalities, batches, point/eval sources, arities, and ordering. @@ -557,7 +557,7 @@ consume a typed Rust-plan / verifier-plan representation produced by passes. parsing or new runtime string dispatch. - Relation strings are converted to typed relation IDs before Rust token emission. -- Output-claim and point-normalization planning can be inspected without +- Relation-output and point-normalization planning can be inspected without reading emitted Rust templates. - The Rust emitter's responsibility is mostly formatting typed const data and importing the right runtime/Jolt-boundary APIs. @@ -580,9 +580,9 @@ eval-family values. ### Current status The scalar/point source registry has been moved out of -`verifier_output_claims` into `verifier_values`. This is only the foundation: +`verifier_relation_outputs` into `verifier_values`. This is only the foundation: it gives scalar and point domains an explicit home. `VerifierStagePlan` now -carries enough scalar/point source data for Stage 3-7 output-claim validation +carries enough scalar/point source data for Stage 3-7 relation-output validation and verifier opening-flow validation to consume plan-derived value sources instead of rebuilding point sources in each stage. Verifier field-flow validation also consumes plan-derived scalar sources; the remaining CPU scalar @@ -597,8 +597,11 @@ bytecode read-RAF relation plans now reference the same plan-level `STAGE*_INDEXED_EVAL_FAMILIES` rows instead of emitting duplicate relation-local `NamedEvalFamilyPlan` constants. Output relation rows now name their terminal scalar `expected_output`, keeping verifier expected-output data -separate from input sumcheck `claim_value` data. Output eval families are still -scalar-output claim machinery rather than first-class value rows. +separate from input sumcheck `claim_value` data. The Rust planning surface now +uses `RelationOutputPlan`, `relation_outputs`, and `STAGE*_RELATION_OUTPUTS` +instead of the old `SumcheckOutputClaimPlan`/`output_claims` names. Output eval +families are still relation-output scalar machinery rather than first-class +value rows. ### Dialect changes @@ -774,7 +777,7 @@ relation code and the runtime against reintroducing indexed eval-prefix APIs. Stage 5 instruction read-RAF and Stage 6 bytecode read-RAF now carry explicit Bolt-side `IndexedEvalFamilyPlan` rows in the verifier-stage plan. The relevant -relation/output-claim planners consume those rows instead of re-deriving the +relation-output planners consume those rows instead of re-deriving the family from raw evals at the point of Rust token emission. Stage 5/6 family membership now originates as first-class @@ -1216,7 +1219,7 @@ next autonomous implementation slices: ```text Current stack. [already in progress] Runtime extraction, typed relation IDs, top-level verifier program, - output-claim plans, cleanup gates. + relation-output plans, cleanup gates. Do S2 boundary audit next. [unconditional] Narrow runtime APIs. diff --git a/crates/bolt/src/protocols/jolt/emit/rust/mod.rs b/crates/bolt/src/protocols/jolt/emit/rust/mod.rs index b2ec52fa0c..3d27780a96 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/mod.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/mod.rs @@ -1,6 +1,6 @@ mod commitment; -mod output_claims; mod plan_tokens; +mod relation_outputs; mod stage1; mod stage2; mod stage3; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs similarity index 79% rename from crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs rename to crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index e302c3b5e1..edfcebd230 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/output_claims.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -1,21 +1,21 @@ use crate::emit::rust::{push_format, EmitError}; use crate::ir::Role; -use crate::protocols::jolt::verifier_output_claims::{ - StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, SumcheckOutputClaimPlan, - SumcheckOutputFunctionKind, +use crate::protocols::jolt::verifier_relation_outputs::{ + RelationOutputFunctionKind, RelationOutputPlan, StructuredPolynomialKind, + StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment, }; -pub fn emit_verifier_output_claim_constants( +pub fn emit_verifier_relation_output_constants( stage_type: &str, role: &Role, - output_claims: &[SumcheckOutputClaimPlan], + relation_outputs: &[RelationOutputPlan], ) -> Result { let mut source = String::new(); let mut claims = Vec::new(); - for (index, claim) in output_claims.iter().enumerate() { + for (index, claim) in relation_outputs.iter().enumerate() { let values_name = format!( - "{}_SUMCHECK_OUTPUT_CLAIM_{index}_VALUES", + "{}_RELATION_OUTPUT_{index}_VALUES", stage_type.to_ascii_uppercase() ); let values = claim @@ -44,17 +44,17 @@ pub fn emit_verifier_output_claim_constants( emit_function_family_constants(&mut source, stage_type, index, claim)?; let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim); claims.push(format!( - " {stage_type}SumcheckOutputClaimPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, product_families: {product_families}, function_families: {function_families}, local_scalars: {local_scalars}, expected_output: {} }},", + " {stage_type}RelationOutputPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, product_families: {product_families}, function_families: {function_families}, local_scalars: {local_scalars}, expected_output: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, rust_str(&claim.expected_output) )); } let claims = claims.join("\n"); - let claims_name = format!("{}_SUMCHECK_OUTPUT_CLAIMS", stage_type.to_ascii_uppercase()); + let claims_name = format!("{}_RELATION_OUTPUTS", stage_type.to_ascii_uppercase()); push_format( &mut source, format_args!( - "pub const {claims_name}: &[{stage_type}SumcheckOutputClaimPlan] = &[\n{claims}\n];\n\n" + "pub const {claims_name}: &[{stage_type}RelationOutputPlan] = &[\n{claims}\n];\n\n" ), ); Ok(source) @@ -64,13 +64,13 @@ fn emit_local_scalar_constants( source: &mut String, stage_type: &str, claim_index: usize, - claim: &SumcheckOutputClaimPlan, + claim: &RelationOutputPlan, ) -> String { if claim.local_scalars.is_empty() { return "&[]".to_owned(); } let name = format!( - "{}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_LOCAL_SCALARS", + "{}_RELATION_OUTPUT_{claim_index}_LOCAL_SCALARS", stage_type.to_ascii_uppercase() ); let scalars = rust_str_array(&claim.local_scalars); @@ -85,7 +85,7 @@ fn emit_eval_family_constants( source: &mut String, stage_type: &str, claim_index: usize, - claim: &SumcheckOutputClaimPlan, + claim: &RelationOutputPlan, ) -> String { if claim.eval_families.is_empty() { return "&[]".to_owned(); @@ -93,8 +93,7 @@ fn emit_eval_family_constants( let upper_stage = stage_type.to_ascii_uppercase(); let mut family_rows = Vec::new(); for (family_index, family) in claim.eval_families.iter().enumerate() { - let prefix = - format!("{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_FAMILY_{family_index}"); + let prefix = format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_FAMILY_{family_index}"); let evals_name = format!("{prefix}_EVALS"); let evals = rust_str_array(&family.evals); push_format( @@ -110,7 +109,7 @@ fn emit_eval_family_constants( .iter() .map(|term| { format!( - " bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan {{ gamma_power_offset: {}, factor: {} }},", + " bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan {{ gamma_power_offset: {}, factor: {} }},", term.gamma_power_offset, rust_str(&term.factor) ) @@ -120,7 +119,7 @@ fn emit_eval_family_constants( push_format( source, format_args!( - "pub const {shared_terms_name}: &[bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan] = &[\n{shared_terms}\n];\n" + "pub const {shared_terms_name}: &[bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan] = &[\n{shared_terms}\n];\n" ), ); @@ -129,7 +128,7 @@ fn emit_eval_family_constants( let factors_name = format!("{prefix}_ITEM_TERM_{term_index}_FACTORS"); let factors = emit_str_slice_or_inline(source, &factors_name, &term.factors); item_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan {{ gamma_power_offset: {}, factors: {factors} }},", + " bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan {{ gamma_power_offset: {}, factors: {factors} }},", term.gamma_power_offset )); } @@ -138,22 +137,22 @@ fn emit_eval_family_constants( push_format( source, format_args!( - "pub const {item_terms_name}: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan] = &[\n{item_terms}\n];\n" + "pub const {item_terms_name}: &[bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan] = &[\n{item_terms}\n];\n" ), ); family_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan {{ symbol: {}, gamma: {}, evals: {evals_name}, power_stride: {}, value_term_offsets: {value_offsets}, shared_terms: {shared_terms_name}, item_terms: {item_terms_name} }},", + " bolt_verifier_runtime::RelationOutputEvalFamilyPlan {{ symbol: {}, gamma: {}, evals: {evals_name}, power_stride: {}, value_term_offsets: {value_offsets}, shared_terms: {shared_terms_name}, item_terms: {item_terms_name} }},", rust_str(&family.symbol), rust_str(&family.gamma), family.power_stride )); } - let families_name = format!("{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_FAMILIES"); + let families_name = format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_FAMILIES"); let families = family_rows.join("\n"); push_format( source, format_args!( - "pub const {families_name}: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan] = &[\n{families}\n];\n\n" + "pub const {families_name}: &[bolt_verifier_runtime::RelationOutputEvalFamilyPlan] = &[\n{families}\n];\n\n" ), ); families_name @@ -163,7 +162,7 @@ fn emit_product_family_constants( source: &mut String, stage_type: &str, claim_index: usize, - claim: &SumcheckOutputClaimPlan, + claim: &RelationOutputPlan, ) -> String { if claim.product_families.is_empty() { return "&[]".to_owned(); @@ -171,9 +170,8 @@ fn emit_product_family_constants( let upper_stage = stage_type.to_ascii_uppercase(); let mut family_rows = Vec::new(); for (family_index, family) in claim.product_families.iter().enumerate() { - let prefix = format!( - "{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_PRODUCT_FAMILY_{family_index}" - ); + let prefix = + format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_PRODUCT_FAMILY_{family_index}"); let mut term_rows = Vec::new(); for (term_index, term) in family.terms.iter().enumerate() { let evals_name = format!("{prefix}_TERM_{term_index}_EVALS"); @@ -184,7 +182,7 @@ fn emit_product_family_constants( let factors_name = format!("{prefix}_TERM_{term_index}_FACTORS"); let factors = emit_str_slice_or_inline(source, &factors_name, &term.factors); term_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan {{ gamma_power_offset: {}, evals: {evals}, eval_families: {eval_families}, factors: {factors} }},", + " bolt_verifier_runtime::RelationOutputProductFamilyTermPlan {{ gamma_power_offset: {}, evals: {evals}, eval_families: {eval_families}, factors: {factors} }},", term.gamma_power_offset )); } @@ -193,22 +191,21 @@ fn emit_product_family_constants( push_format( source, format_args!( - "pub const {terms_name}: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[\n{terms}\n];\n" + "pub const {terms_name}: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[\n{terms}\n];\n" ), ); family_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputProductFamilyPlan {{ symbol: {}, gamma: {}, terms: {terms_name} }},", + " bolt_verifier_runtime::RelationOutputProductFamilyPlan {{ symbol: {}, gamma: {}, terms: {terms_name} }},", rust_str(&family.symbol), optional_rust_str(family.gamma.as_deref()), )); } - let families_name = - format!("{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_PRODUCT_FAMILIES"); + let families_name = format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_PRODUCT_FAMILIES"); let families = family_rows.join("\n"); push_format( source, format_args!( - "pub const {families_name}: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[\n{families}\n];\n\n" + "pub const {families_name}: &[bolt_verifier_runtime::RelationOutputProductFamilyPlan] = &[\n{families}\n];\n\n" ), ); families_name @@ -218,7 +215,7 @@ fn emit_function_family_constants( source: &mut String, stage_type: &str, claim_index: usize, - claim: &SumcheckOutputClaimPlan, + claim: &RelationOutputPlan, ) -> Result { if claim.function_families.is_empty() { return Ok("&[]".to_owned()); @@ -226,17 +223,16 @@ fn emit_function_family_constants( let upper_stage = stage_type.to_ascii_uppercase(); let mut family_rows = Vec::new(); for (family_index, family) in claim.function_families.iter().enumerate() { - let prefix = format!( - "{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_FUNCTION_FAMILY_{family_index}" - ); + let prefix = + format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_FUNCTION_FAMILY_{family_index}"); let mut term_rows = Vec::new(); for (term_index, term) in family.terms.iter().enumerate() { let factors_name = format!("{prefix}_TERM_{term_index}_FACTORS"); let factors = emit_str_slice_or_inline(source, &factors_name, &term.factors); term_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan {{ gamma_power_offset: {}, function: {}, eval: {}, factors: {factors} }},", + " bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan {{ gamma_power_offset: {}, function: {}, eval: {}, factors: {factors} }},", term.gamma_power_offset, - output_function_kind_expr(term.function), + relation_output_function_kind_expr(term.function), rust_str(&term.eval) )); } @@ -245,31 +241,30 @@ fn emit_function_family_constants( push_format( source, format_args!( - "pub const {terms_name}: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan] = &[\n{terms}\n];\n" + "pub const {terms_name}: &[bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan] = &[\n{terms}\n];\n" ), ); family_rows.push(format!( - " bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan {{ symbol: {}, gamma: {}, terms: {terms_name} }},", + " bolt_verifier_runtime::RelationOutputFunctionFamilyPlan {{ symbol: {}, gamma: {}, terms: {terms_name} }},", rust_str(&family.symbol), optional_rust_str(family.gamma.as_deref()), )); } - let families_name = - format!("{upper_stage}_SUMCHECK_OUTPUT_CLAIM_{claim_index}_FUNCTION_FAMILIES"); + let families_name = format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_FUNCTION_FAMILIES"); let families = family_rows.join("\n"); push_format( source, format_args!( - "pub const {families_name}: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan] = &[\n{families}\n];\n\n" + "pub const {families_name}: &[bolt_verifier_runtime::RelationOutputFunctionFamilyPlan] = &[\n{families}\n];\n\n" ), ); Ok(families_name) } -fn output_function_kind_expr(function: SumcheckOutputFunctionKind) -> &'static str { +fn relation_output_function_kind_expr(function: RelationOutputFunctionKind) -> &'static str { match function { - SumcheckOutputFunctionKind::BooleanZero => { - "bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero" + RelationOutputFunctionKind::BooleanZero => { + "bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero" } } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 66fb33966d..dd226ce474 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -6,14 +6,13 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::verifier_output_claims::{ - self, FieldExprDependencies, +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_relation_outputs::{ + self, FieldExprDependencies, RelationOutputAst as Stage3RelationOutputAst, + RelationOutputPlan as Stage3RelationOutputPlan, StructuredPolynomialEvalPlan as Stage3StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage3StructuredPolynomialPointPlan, - SumcheckOutputClaimAst as Stage3SumcheckOutputClaimAst, - SumcheckOutputClaimPlan as Stage3SumcheckOutputClaimPlan, }; -use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -33,8 +32,8 @@ pub struct Stage3CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, - pub output_values: Vec, - pub output_claims: Vec, + pub relation_output_values: Vec, + pub relation_outputs: Vec, pub point_slices: Vec, pub point_concats: Vec, pub opening_claims: Vec, @@ -272,8 +271,8 @@ impl Stage3CpuProgram { let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); - let mut output_values = Vec::new(); - let mut output_claim_asts = Vec::new(); + let mut relation_output_values = Vec::new(); + let mut relation_output_asts = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); let mut opening_claims = Vec::new(); @@ -502,7 +501,7 @@ impl Stage3CpuProgram { string_attr(op, "y_point_length")?, string_attr(op, "y_point_order")?, )?; - output_values.push(Stage3StructuredPolynomialEvalPlan::from_cpu( + relation_output_values.push(Stage3StructuredPolynomialEvalPlan::from_cpu( symbol, string_attr(op, "polynomial")?, x_point, @@ -510,7 +509,7 @@ impl Stage3CpuProgram { )?); } "cpu.sumcheck_output_claim" => { - output_claim_asts.push(Stage3SumcheckOutputClaimAst { + relation_output_asts.push(Stage3RelationOutputAst { relation: symbol_attr(op, "relation")?, expected_output: operand_symbol(op, 0)?, polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, @@ -573,23 +572,23 @@ impl Stage3CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if role == Role::Prover { - verifier_output_claims::prune_output_only_field_exprs( + verifier_relation_outputs::prune_output_only_field_exprs( &mut field_exprs, claims.iter().map(|claim| claim.claim_value.as_str()), - output_claim_asts + relation_output_asts .iter() .map(|claim| claim.expected_output.as_str()), ); } - let output_claims = if role == Role::Verifier { - verifier_output_claims::resolve_output_claims( + let relation_outputs = if role == Role::Verifier { + verifier_relation_outputs::resolve_relation_outputs( "stage3", - &output_values, + &relation_output_values, &[], &[], &[], &field_exprs, - output_claim_asts, + relation_output_asts, )? } else { Vec::new() @@ -610,8 +609,8 @@ impl Stage3CpuProgram { drivers, instance_results, evals, - output_values, - output_claims, + relation_output_values, + relation_outputs, point_slices, point_concats, opening_claims, @@ -649,7 +648,7 @@ impl Stage3CpuProgram { Role::Verifier => self.verify_verifier_driver_bindings()?, } if self.role == Role::Verifier { - self.verify_output_claims()?; + self.verify_relation_outputs()?; } self.verify_opening_flow() } @@ -737,7 +736,9 @@ impl Stage3CpuProgram { verifier_values::VerifierScalarSourceKind::SumcheckEval, ); values.extend( - self.output_values.iter().map(|value| &value.symbol), + self.relation_output_values + .iter() + .map(|value| &value.symbol), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values @@ -916,7 +917,7 @@ impl Stage3CpuProgram { Ok(()) } - fn verify_output_claims(&self) -> Result<(), EmitError> { + fn verify_relation_outputs(&self) -> Result<(), EmitError> { let relations = symbols( self.instance_results .iter() @@ -925,14 +926,14 @@ impl Stage3CpuProgram { let plan = self.verifier_plan()?; let field_values = plan.scalar_value_sources(); let point_values = plan.point_value_sources(); - verifier_output_claims::verify_output_claims( + verifier_relation_outputs::verify_relation_outputs( "stage3", - verifier_output_claims::OutputClaimVerification { - output_values: &self.output_values, - output_families: &[], - output_product_families: &[], - output_function_families: &[], - output_claims: &self.output_claims, + verifier_relation_outputs::RelationOutputVerification { + relation_output_values: &self.relation_output_values, + relation_output_eval_families: &[], + relation_output_product_families: &[], + relation_output_function_families: &[], + relation_outputs: &self.relation_outputs, relations: &relations, field_values: &field_values, point_values: &point_values, @@ -1143,7 +1144,7 @@ pub type Stage3VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgram pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage3SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub type Stage3SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage3RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub type Stage3StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind; @@ -1222,7 +1223,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_verifier_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); - source.push_str(&self.emit_verifier_output_claim_constants()?); + source.push_str(&self.emit_verifier_relation_output_constants()?); source.push_str( "pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan {\n\ \x20 params: STAGE3_PARAMS,\n\ @@ -1236,7 +1237,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); \x20 drivers: STAGE3_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE3_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE3_SUMCHECK_EVALS,\n\ - \x20 output_claims: STAGE3_SUMCHECK_OUTPUT_CLAIMS,\n\ + \x20 relation_outputs: STAGE3_RELATION_OUTPUTS,\n\ \x20 point_slices: STAGE3_POINT_SLICES,\n\ \x20 point_concats: STAGE3_POINT_CONCATS,\n\ \x20 opening_claims: STAGE3_OPENING_CLAIMS,\n\ @@ -1704,11 +1705,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); format!("pub const STAGE3_SUMCHECK_EVALS: &[Stage3SumcheckEvalPlan] = &[\n{evals}\n];\n\n") } - fn emit_verifier_output_claim_constants(&self) -> Result { - super::output_claims::emit_verifier_output_claim_constants( + fn emit_verifier_relation_output_constants(&self) -> Result { + super::relation_outputs::emit_verifier_relation_output_constants( "Stage3", &self.role, - &self.output_claims, + &self.relation_outputs, ) } @@ -2169,8 +2170,8 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let value = bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index ab78ad349d..43db1a0afe 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -11,14 +11,13 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::verifier_output_claims::{ - self, FieldExprDependencies, +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_relation_outputs::{ + self, FieldExprDependencies, RelationOutputAst as Stage4RelationOutputAst, + RelationOutputPlan as Stage4RelationOutputPlan, StructuredPolynomialEvalPlan as Stage4StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage4StructuredPolynomialPointPlan, - SumcheckOutputClaimAst as Stage4SumcheckOutputClaimAst, - SumcheckOutputClaimPlan as Stage4SumcheckOutputClaimPlan, }; -use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -39,8 +38,8 @@ pub struct Stage4CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, - pub output_values: Vec, - pub output_claims: Vec, + pub relation_output_values: Vec, + pub relation_outputs: Vec, pub point_slices: Vec, pub point_concats: Vec, pub opening_claims: Vec, @@ -287,8 +286,8 @@ impl Stage4CpuProgram { let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); - let mut output_values = Vec::new(); - let mut output_claim_asts = Vec::new(); + let mut relation_output_values = Vec::new(); + let mut relation_output_asts = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); let mut opening_claims = Vec::new(); @@ -514,7 +513,7 @@ impl Stage4CpuProgram { string_attr(op, "y_point_length")?, string_attr(op, "y_point_order")?, )?; - output_values.push(Stage4StructuredPolynomialEvalPlan::from_cpu( + relation_output_values.push(Stage4StructuredPolynomialEvalPlan::from_cpu( symbol, string_attr(op, "polynomial")?, x_point, @@ -522,7 +521,7 @@ impl Stage4CpuProgram { )?); } "cpu.sumcheck_output_claim" => { - output_claim_asts.push(Stage4SumcheckOutputClaimAst { + relation_output_asts.push(Stage4RelationOutputAst { relation: symbol_attr(op, "relation")?, expected_output: operand_symbol(op, 0)?, polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, @@ -585,23 +584,23 @@ impl Stage4CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if role == Role::Prover { - verifier_output_claims::prune_output_only_field_exprs( + verifier_relation_outputs::prune_output_only_field_exprs( &mut field_exprs, claims.iter().map(|claim| claim.claim_value.as_str()), - output_claim_asts + relation_output_asts .iter() .map(|claim| claim.expected_output.as_str()), ); } - let output_claims = if role == Role::Verifier { - verifier_output_claims::resolve_output_claims( + let relation_outputs = if role == Role::Verifier { + verifier_relation_outputs::resolve_relation_outputs( "stage4", - &output_values, + &relation_output_values, &[], &[], &[], &field_exprs, - output_claim_asts, + relation_output_asts, )? } else { Vec::new() @@ -623,8 +622,8 @@ impl Stage4CpuProgram { drivers, instance_results, evals, - output_values, - output_claims, + relation_output_values, + relation_outputs, point_slices, point_concats, opening_claims, @@ -662,7 +661,7 @@ impl Stage4CpuProgram { Role::Verifier => self.verify_verifier_driver_bindings()?, } if self.role == Role::Verifier { - self.verify_output_claims()?; + self.verify_relation_outputs()?; } self.verify_opening_flow() } @@ -750,7 +749,9 @@ impl Stage4CpuProgram { verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); values.extend( - self.output_values.iter().map(|value| &value.symbol), + self.relation_output_values + .iter() + .map(|value| &value.symbol), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( @@ -936,7 +937,7 @@ impl Stage4CpuProgram { Ok(()) } - fn verify_output_claims(&self) -> Result<(), EmitError> { + fn verify_relation_outputs(&self) -> Result<(), EmitError> { let relations = symbols( self.instance_results .iter() @@ -945,14 +946,14 @@ impl Stage4CpuProgram { let plan = self.verifier_plan()?; let field_values = plan.scalar_value_sources(); let point_values = plan.point_value_sources(); - verifier_output_claims::verify_output_claims( + verifier_relation_outputs::verify_relation_outputs( "stage4", - verifier_output_claims::OutputClaimVerification { - output_values: &self.output_values, - output_families: &[], - output_product_families: &[], - output_function_families: &[], - output_claims: &self.output_claims, + verifier_relation_outputs::RelationOutputVerification { + relation_output_values: &self.relation_output_values, + relation_output_eval_families: &[], + relation_output_product_families: &[], + relation_output_function_families: &[], + relation_outputs: &self.relation_outputs, relations: &relations, field_values: &field_values, point_values: &point_values, @@ -1355,7 +1356,7 @@ pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZe pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage4SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub type Stage4SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage4RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub type Stage4StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind; @@ -1418,10 +1419,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); if self.role == Role::Verifier { - source.push_str(&self.emit_verifier_output_claim_constants()?); + source.push_str(&self.emit_verifier_relation_output_constants()?); } - let output_claims_field = if self.role == Role::Verifier { - " output_claims: STAGE4_SUMCHECK_OUTPUT_CLAIMS,\n" + let relation_outputs_field = if self.role == Role::Verifier { + " relation_outputs: STAGE4_RELATION_OUTPUTS,\n" } else { "" }; @@ -1443,7 +1444,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); \x20 drivers: STAGE4_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE4_SUMCHECK_EVALS,\n\ - {output_claims_field}\ + {relation_outputs_field}\ \x20 point_slices: STAGE4_POINT_SLICES,\n\ \x20 point_concats: STAGE4_POINT_CONCATS,\n\ \x20 opening_claims: STAGE4_OPENING_CLAIMS,\n\ @@ -1933,11 +1934,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); format!("pub const STAGE4_SUMCHECK_EVALS: &[Stage4SumcheckEvalPlan] = &[\n{evals}\n];\n\n") } - fn emit_verifier_output_claim_constants(&self) -> Result { - super::output_claims::emit_verifier_output_claim_constants( + fn emit_verifier_relation_output_constants(&self) -> Result { + super::relation_outputs::emit_verifier_relation_output_constants( "Stage4", &self.role, - &self.output_claims, + &self.relation_outputs, ) } @@ -2411,8 +2412,8 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let value = bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index df62905f6d..2be8c9b15a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -15,18 +15,18 @@ use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, }; use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; -use crate::protocols::jolt::verifier_output_claims::{ +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, + RelationOutputAst as Stage5RelationOutputAst, + RelationOutputEvalFamilyPlan as Stage5RelationOutputEvalFamilyPlan, + RelationOutputFunctionFamilyPlan as Stage5RelationOutputFunctionFamilyPlan, + RelationOutputPlan as Stage5RelationOutputPlan, + RelationOutputProductFamilyPlan as Stage5RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, - SumcheckOutputClaimAst as Stage5SumcheckOutputClaimAst, - SumcheckOutputClaimPlan as Stage5SumcheckOutputClaimPlan, - SumcheckOutputEvalFamilyPlan as Stage5SumcheckOutputEvalFamilyPlan, - SumcheckOutputFunctionFamilyPlan as Stage5SumcheckOutputFunctionFamilyPlan, - SumcheckOutputProductFamilyPlan as Stage5SumcheckOutputProductFamilyPlan, }; -use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -48,11 +48,11 @@ pub struct Stage5CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, - pub output_values: Vec, - pub output_families: Vec, - pub output_product_families: Vec, - pub output_function_families: Vec, - pub output_claims: Vec, + pub relation_output_values: Vec, + pub relation_output_eval_families: Vec, + pub relation_output_product_families: Vec, + pub relation_output_function_families: Vec, + pub relation_outputs: Vec, pub point_slices: Vec, pub point_concats: Vec, pub opening_claims: Vec, @@ -277,9 +277,9 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_batch = Stage5OpeningBatchPlan, absorb = Stage5TranscriptAbsorbBytesPlan, indexed_eval_families = indexed_eval_families, - output_families = output_families, - output_product_families = output_product_families, - output_function_families = output_function_families, + relation_output_eval_families = relation_output_eval_families, + relation_output_product_families = relation_output_product_families, + relation_output_function_families = relation_output_function_families, ); pub fn stage5_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -314,11 +314,11 @@ impl Stage5CpuProgram { let mut instance_results = Vec::new(); let mut evals = Vec::new(); let mut indexed_eval_families = Vec::new(); - let mut output_values = Vec::new(); - let mut output_families = Vec::new(); - let mut output_product_families = Vec::new(); - let mut output_function_families = Vec::new(); - let mut output_claim_asts = Vec::new(); + let mut relation_output_values = Vec::new(); + let mut relation_output_eval_families = Vec::new(); + let mut relation_output_product_families = Vec::new(); + let mut relation_output_function_families = Vec::new(); + let mut relation_output_asts = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); let mut opening_claims = Vec::new(); @@ -547,7 +547,7 @@ impl Stage5CpuProgram { string_attr(op, "y_point_length")?, string_attr(op, "y_point_order")?, )?; - output_values.push(Stage5StructuredPolynomialEvalPlan::from_cpu( + relation_output_values.push(Stage5StructuredPolynomialEvalPlan::from_cpu( symbol, string_attr(op, "polynomial")?, x_point, @@ -555,16 +555,19 @@ impl Stage5CpuProgram { )?); } "cpu.sumcheck_output_eval_family" => { - output_families.push(parse_output_eval_family_plan("stage5", op)?); + relation_output_eval_families + .push(parse_output_eval_family_plan("stage5", op)?); } "cpu.sumcheck_output_product_family" => { - output_product_families.push(parse_output_product_family_plan("stage5", op)?); + relation_output_product_families + .push(parse_output_product_family_plan("stage5", op)?); } "cpu.sumcheck_output_function_family" => { - output_function_families.push(parse_output_function_family_plan("stage5", op)?); + relation_output_function_families + .push(parse_output_function_family_plan("stage5", op)?); } "cpu.sumcheck_output_claim" => { - output_claim_asts.push(Stage5SumcheckOutputClaimAst { + relation_output_asts.push(Stage5RelationOutputAst { relation: symbol_attr(op, "relation")?, expected_output: operand_symbol(op, 0)?, polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, @@ -627,23 +630,23 @@ impl Stage5CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if role == Role::Prover { - verifier_output_claims::prune_output_only_field_exprs( + verifier_relation_outputs::prune_output_only_field_exprs( &mut field_exprs, claims.iter().map(|claim| claim.claim_value.as_str()), - output_claim_asts + relation_output_asts .iter() .map(|claim| claim.expected_output.as_str()), ); } - let mut output_claims = if role == Role::Verifier { - verifier_output_claims::resolve_output_claims( + let mut relation_outputs = if role == Role::Verifier { + verifier_relation_outputs::resolve_relation_outputs( "stage5", - &output_values, - &output_families, - &output_product_families, - &output_function_families, + &relation_output_values, + &relation_output_eval_families, + &relation_output_product_families, + &relation_output_function_families, &field_exprs, - output_claim_asts, + relation_output_asts, )? } else { Vec::new() @@ -651,9 +654,9 @@ impl Stage5CpuProgram { if role == Role::Verifier { let output_plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&indexed_eval_families)? - .output_claim_plan(); + .relation_output_plan(); field_exprs.extend(output_plan.field_exprs.into_iter().map(stage5_field_expr)); - output_claims.push(output_plan.claim); + relation_outputs.push(output_plan.claim); } let mut program = Self { @@ -673,11 +676,11 @@ impl Stage5CpuProgram { drivers, instance_results, evals, - output_values, - output_families, - output_product_families, - output_function_families, - output_claims, + relation_output_values, + relation_output_eval_families, + relation_output_product_families, + relation_output_function_families, + relation_outputs, point_slices, point_concats, opening_claims, @@ -715,7 +718,7 @@ impl Stage5CpuProgram { Role::Verifier => self.verify_verifier_driver_bindings()?, } if self.role == Role::Verifier { - self.verify_output_claims()?; + self.verify_relation_outputs()?; } self.verify_opening_flow() } @@ -803,45 +806,49 @@ impl Stage5CpuProgram { verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); values.extend( - self.output_values.iter().map(|value| &value.symbol), + self.relation_output_values + .iter() + .map(|value| &value.symbol), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( - self.output_families.iter().map(|family| &family.symbol), + self.relation_output_eval_families + .iter() + .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( - self.output_product_families + self.relation_output_product_families .iter() .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); values.extend( - self.output_function_families + self.relation_output_function_families .iter() .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), verifier_values::VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, @@ -851,7 +858,7 @@ impl Stage5CpuProgram { verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.local_scalars.iter()), verifier_values::VerifierScalarSourceKind::PointDerived, @@ -1036,7 +1043,7 @@ impl Stage5CpuProgram { Ok(()) } - fn verify_output_claims(&self) -> Result<(), EmitError> { + fn verify_relation_outputs(&self) -> Result<(), EmitError> { let relations = symbols( self.instance_results .iter() @@ -1045,14 +1052,14 @@ impl Stage5CpuProgram { let plan = self.verifier_plan()?; let field_values = plan.scalar_value_sources(); let point_values = plan.point_value_sources(); - verifier_output_claims::verify_output_claims( + verifier_relation_outputs::verify_relation_outputs( "stage5", - verifier_output_claims::OutputClaimVerification { - output_values: &self.output_values, - output_families: &self.output_families, - output_product_families: &self.output_product_families, - output_function_families: &self.output_function_families, - output_claims: &self.output_claims, + verifier_relation_outputs::RelationOutputVerification { + relation_output_values: &self.relation_output_values, + relation_output_eval_families: &self.relation_output_eval_families, + relation_output_product_families: &self.relation_output_product_families, + relation_output_function_families: &self.relation_output_function_families, + relation_outputs: &self.relation_outputs, relations: &relations, field_values: &field_values, point_values: &point_values, @@ -1456,7 +1463,7 @@ pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZe pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage5SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub type Stage5SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage5RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub type Stage5StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage5RelationKind; @@ -1520,10 +1527,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); source.push_str(&self.emit_tail_constants()?); if self.role == Role::Verifier { source.push_str(&self.emit_indexed_eval_family_constants()?); - source.push_str(&self.emit_verifier_output_claim_constants()?); + source.push_str(&self.emit_verifier_relation_output_constants()?); } - let output_claims_field = if self.role == Role::Verifier { - " output_claims: STAGE5_SUMCHECK_OUTPUT_CLAIMS,\n" + let relation_outputs_field = if self.role == Role::Verifier { + " relation_outputs: STAGE5_RELATION_OUTPUTS,\n" } else { "" }; @@ -1545,7 +1552,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); \x20 drivers: STAGE5_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE5_SUMCHECK_EVALS,\n\ - {output_claims_field}\ + {relation_outputs_field}\ \x20 point_slices: STAGE5_POINT_SLICES,\n\ \x20 point_concats: STAGE5_POINT_CONCATS,\n\ \x20 opening_claims: STAGE5_OPENING_CLAIMS,\n\ @@ -2028,11 +2035,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); Ok(plan.emit_runtime_constants()) } - fn emit_verifier_output_claim_constants(&self) -> Result { - super::output_claims::emit_verifier_output_claim_constants( + fn emit_verifier_relation_output_constants(&self) -> Result { + super::relation_outputs::emit_verifier_relation_output_constants( "Stage5", &self.role, - &self.output_claims, + &self.relation_outputs, ) } @@ -2504,8 +2511,8 @@ fn expected_batched_output_claim( &STAGE5_INSTRUCTION_READ_RAF_PLAN, local_point, )?; - bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, @@ -2517,8 +2524,8 @@ fn expected_batched_output_claim( } Stage5RelationKind::Stage5RamRaClaimReduction | Stage5RelationKind::Stage5RegistersValEvaluation => { - bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index d289e5b875..2fe8e3406e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -13,21 +13,21 @@ use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, - stage6_bytecode_read_raf_output_claim_plan, STAGE6_BYTECODE_RA_EVAL_FAMILY, + stage6_bytecode_read_raf_relation_output_plan, STAGE6_BYTECODE_RA_EVAL_FAMILY, }; use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; -use crate::protocols::jolt::verifier_output_claims::{ +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, + RelationOutputAst as Stage6RelationOutputAst, + RelationOutputEvalFamilyPlan as Stage6RelationOutputEvalFamilyPlan, + RelationOutputFunctionFamilyPlan as Stage6RelationOutputFunctionFamilyPlan, + RelationOutputPlan as Stage6RelationOutputPlan, + RelationOutputProductFamilyPlan as Stage6RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, - SumcheckOutputClaimAst as Stage6SumcheckOutputClaimAst, - SumcheckOutputClaimPlan as Stage6SumcheckOutputClaimPlan, - SumcheckOutputEvalFamilyPlan as Stage6SumcheckOutputEvalFamilyPlan, - SumcheckOutputFunctionFamilyPlan as Stage6SumcheckOutputFunctionFamilyPlan, - SumcheckOutputProductFamilyPlan as Stage6SumcheckOutputProductFamilyPlan, }; -use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -76,11 +76,11 @@ pub struct Stage6CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, - pub output_values: Vec, - pub output_families: Vec, - pub output_product_families: Vec, - pub output_function_families: Vec, - pub output_claims: Vec, + pub relation_output_values: Vec, + pub relation_output_eval_families: Vec, + pub relation_output_product_families: Vec, + pub relation_output_function_families: Vec, + pub relation_outputs: Vec, pub point_zeros: Vec, pub point_slices: Vec, pub point_concats: Vec, @@ -304,9 +304,9 @@ verifier_plan::impl_verifier_plan_source_traits!( absorb = Stage6TranscriptAbsorbBytesPlan, point_zero = Stage6PointZeroPlan, indexed_eval_families = indexed_eval_families, - output_families = output_families, - output_product_families = output_product_families, - output_function_families = output_function_families, + relation_output_eval_families = relation_output_eval_families, + relation_output_product_families = relation_output_product_families, + relation_output_function_families = relation_output_function_families, ); pub fn stage6_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -341,11 +341,11 @@ impl Stage6CpuProgram { let mut instance_results = Vec::new(); let mut evals = Vec::new(); let mut indexed_eval_families = Vec::new(); - let mut output_values = Vec::new(); - let mut output_families = Vec::new(); - let mut output_product_families = Vec::new(); - let mut output_function_families = Vec::new(); - let mut output_claim_asts = Vec::new(); + let mut relation_output_values = Vec::new(); + let mut relation_output_eval_families = Vec::new(); + let mut relation_output_product_families = Vec::new(); + let mut relation_output_function_families = Vec::new(); + let mut relation_output_asts = Vec::new(); let mut point_zeros = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); @@ -575,7 +575,7 @@ impl Stage6CpuProgram { string_attr(op, "y_point_length")?, string_attr(op, "y_point_order")?, )?; - output_values.push(Stage6StructuredPolynomialEvalPlan::from_cpu( + relation_output_values.push(Stage6StructuredPolynomialEvalPlan::from_cpu( symbol, string_attr(op, "polynomial")?, x_point, @@ -583,16 +583,19 @@ impl Stage6CpuProgram { )?); } "cpu.sumcheck_output_eval_family" => { - output_families.push(parse_output_eval_family_plan("stage6", op)?); + relation_output_eval_families + .push(parse_output_eval_family_plan("stage6", op)?); } "cpu.sumcheck_output_product_family" => { - output_product_families.push(parse_output_product_family_plan("stage6", op)?); + relation_output_product_families + .push(parse_output_product_family_plan("stage6", op)?); } "cpu.sumcheck_output_function_family" => { - output_function_families.push(parse_output_function_family_plan("stage6", op)?); + relation_output_function_families + .push(parse_output_function_family_plan("stage6", op)?); } "cpu.sumcheck_output_claim" => { - output_claim_asts.push(Stage6SumcheckOutputClaimAst { + relation_output_asts.push(Stage6RelationOutputAst { relation: symbol_attr(op, "relation")?, expected_output: operand_symbol(op, 0)?, polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, @@ -662,23 +665,23 @@ impl Stage6CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if role == Role::Prover { - verifier_output_claims::prune_output_only_field_exprs( + verifier_relation_outputs::prune_output_only_field_exprs( &mut field_exprs, claims.iter().map(|claim| claim.claim_value.as_str()), - output_claim_asts + relation_output_asts .iter() .map(|claim| claim.expected_output.as_str()), ); } - let mut output_claims = if role == Role::Verifier { - verifier_output_claims::resolve_output_claims( + let mut relation_outputs = if role == Role::Verifier { + verifier_relation_outputs::resolve_relation_outputs( "stage6", - &output_values, - &output_families, - &output_product_families, - &output_function_families, + &relation_output_values, + &relation_output_eval_families, + &relation_output_product_families, + &relation_output_function_families, &field_exprs, - output_claim_asts, + relation_output_asts, )? } else { Vec::new() @@ -688,7 +691,7 @@ impl Stage6CpuProgram { &indexed_eval_families, STAGE6_BYTECODE_RA_EVAL_FAMILY, )?; - output_claims.push(stage6_bytecode_read_raf_output_claim_plan( + relation_outputs.push(stage6_bytecode_read_raf_relation_output_plan( bytecode_ra_evals, )); } @@ -710,11 +713,11 @@ impl Stage6CpuProgram { drivers, instance_results, evals, - output_values, - output_families, - output_product_families, - output_function_families, - output_claims, + relation_output_values, + relation_output_eval_families, + relation_output_product_families, + relation_output_function_families, + relation_outputs, point_zeros, point_slices, point_concats, @@ -753,7 +756,7 @@ impl Stage6CpuProgram { Role::Verifier => self.verify_verifier_driver_bindings()?, } if self.role == Role::Verifier { - self.verify_output_claims()?; + self.verify_relation_outputs()?; } self.verify_opening_flow() } @@ -841,45 +844,49 @@ impl Stage6CpuProgram { verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); values.extend( - self.output_values.iter().map(|value| &value.symbol), + self.relation_output_values + .iter() + .map(|value| &value.symbol), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( - self.output_families.iter().map(|family| &family.symbol), + self.relation_output_eval_families + .iter() + .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( - self.output_product_families + self.relation_output_product_families .iter() .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); values.extend( - self.output_function_families + self.relation_output_function_families .iter() .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), verifier_values::VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, @@ -889,7 +896,7 @@ impl Stage6CpuProgram { verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.local_scalars.iter()), verifier_values::VerifierScalarSourceKind::PointDerived, @@ -1068,7 +1075,7 @@ impl Stage6CpuProgram { Ok(()) } - fn verify_output_claims(&self) -> Result<(), EmitError> { + fn verify_relation_outputs(&self) -> Result<(), EmitError> { let relations = symbols( self.instance_results .iter() @@ -1077,14 +1084,14 @@ impl Stage6CpuProgram { let plan = self.verifier_plan()?; let field_values = plan.scalar_value_sources(); let point_values = plan.point_value_sources(); - verifier_output_claims::verify_output_claims( + verifier_relation_outputs::verify_relation_outputs( "stage6", - verifier_output_claims::OutputClaimVerification { - output_values: &self.output_values, - output_families: &self.output_families, - output_product_families: &self.output_product_families, - output_function_families: &self.output_function_families, - output_claims: &self.output_claims, + verifier_relation_outputs::RelationOutputVerification { + relation_output_values: &self.relation_output_values, + relation_output_eval_families: &self.relation_output_eval_families, + relation_output_product_families: &self.relation_output_product_families, + relation_output_function_families: &self.relation_output_function_families, + relation_outputs: &self.relation_outputs, relations: &relations, field_values: &field_values, point_values: &point_values, @@ -1500,7 +1507,7 @@ pub type Stage6CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage6SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage6SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub type Stage6SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage6RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub type Stage6StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage6RelationKind; @@ -1627,10 +1634,10 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&emit_stage6_bytecode_read_raf_plan_constants( &bytecode_ra_evals_ref, )); - source.push_str(&self.emit_verifier_output_claim_constants()?); + source.push_str(&self.emit_verifier_relation_output_constants()?); } - let output_claims_field = if self.role == Role::Verifier { - " output_claims: STAGE6_SUMCHECK_OUTPUT_CLAIMS,\n" + let relation_outputs_field = if self.role == Role::Verifier { + " relation_outputs: STAGE6_RELATION_OUTPUTS,\n" } else { "" }; @@ -1652,7 +1659,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); \x20 drivers: STAGE6_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE6_SUMCHECK_EVALS,\n\ - {output_claims_field}\ + {relation_outputs_field}\ \x20 point_zeros: STAGE6_POINT_ZEROS,\n\ \x20 point_slices: STAGE6_POINT_SLICES,\n\ \x20 point_concats: STAGE6_POINT_CONCATS,\n\ @@ -2138,11 +2145,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); )) } - fn emit_verifier_output_claim_constants(&self) -> Result { - super::output_claims::emit_verifier_output_claim_constants( + fn emit_verifier_relation_output_constants(&self) -> Result { + super::relation_outputs::emit_verifier_relation_output_constants( "Stage6", &self.role, - &self.output_claims, + &self.relation_outputs, ) } @@ -2677,13 +2684,13 @@ fn expected_batched_output_claim( local_point, log_t, )?; - expected_plan_output_claim(program, instance, store, evals, &local_scalars, local_point)? + expected_plan_relation_output(program, instance, store, evals, &local_scalars, local_point)? } Stage6RelationKind::Stage6Booleanity | Stage6RelationKind::Stage6HammingBooleanity | Stage6RelationKind::Stage6RamRaVirtual | Stage6RelationKind::Stage6InstructionRaVirtual - | Stage6RelationKind::Stage6IncClaimReduction => expected_plan_output_claim( + | Stage6RelationKind::Stage6IncClaimReduction => expected_plan_relation_output( program, instance, store, @@ -2698,7 +2705,7 @@ fn expected_batched_output_claim( Ok(expected) } -fn expected_plan_output_claim( +fn expected_plan_relation_output( program: &'static Stage6VerifierProgramPlan, instance: &'static Stage6SumcheckInstanceResultPlan, store: &bolt_verifier_runtime::ValueStore, @@ -2706,8 +2713,8 @@ fn expected_plan_output_claim( local_scalars: &[bolt_verifier_runtime::NamedScalar], local_point: &[Fr], ) -> Result { - Ok(bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + Ok(bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index ea775079a7..9e71c6fd3e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -11,18 +11,18 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::verifier_output_claims::{ +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, FieldExprDependencies, + RelationOutputAst as Stage7RelationOutputAst, + RelationOutputEvalFamilyPlan as Stage7RelationOutputEvalFamilyPlan, + RelationOutputFunctionFamilyPlan as Stage7RelationOutputFunctionFamilyPlan, + RelationOutputPlan as Stage7RelationOutputPlan, + RelationOutputProductFamilyPlan as Stage7RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan, StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, - SumcheckOutputClaimAst as Stage7SumcheckOutputClaimAst, - SumcheckOutputClaimPlan as Stage7SumcheckOutputClaimPlan, - SumcheckOutputEvalFamilyPlan as Stage7SumcheckOutputEvalFamilyPlan, - SumcheckOutputFunctionFamilyPlan as Stage7SumcheckOutputFunctionFamilyPlan, - SumcheckOutputProductFamilyPlan as Stage7SumcheckOutputProductFamilyPlan, }; -use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -56,11 +56,11 @@ pub struct Stage7CpuProgram { pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, - pub output_values: Vec, - pub output_families: Vec, - pub output_product_families: Vec, - pub output_function_families: Vec, - pub output_claims: Vec, + pub relation_output_values: Vec, + pub relation_output_eval_families: Vec, + pub relation_output_product_families: Vec, + pub relation_output_function_families: Vec, + pub relation_outputs: Vec, pub point_zeros: Vec, pub point_slices: Vec, pub point_concats: Vec, @@ -283,9 +283,9 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_batch = Stage7OpeningBatchPlan, absorb = Stage7TranscriptAbsorbBytesPlan, point_zero = Stage7PointZeroPlan, - output_families = output_families, - output_product_families = output_product_families, - output_function_families = output_function_families, + relation_output_eval_families = relation_output_eval_families, + relation_output_product_families = relation_output_product_families, + relation_output_function_families = relation_output_function_families, ); pub fn stage7_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -319,11 +319,11 @@ impl Stage7CpuProgram { let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); - let mut output_values = Vec::new(); - let mut output_families = Vec::new(); - let mut output_product_families = Vec::new(); - let mut output_function_families = Vec::new(); - let mut output_claim_asts = Vec::new(); + let mut relation_output_values = Vec::new(); + let mut relation_output_eval_families = Vec::new(); + let mut relation_output_product_families = Vec::new(); + let mut relation_output_function_families = Vec::new(); + let mut relation_output_asts = Vec::new(); let mut point_zeros = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); @@ -550,7 +550,7 @@ impl Stage7CpuProgram { string_attr(op, "y_point_length")?, string_attr(op, "y_point_order")?, )?; - output_values.push(Stage7StructuredPolynomialEvalPlan::from_cpu( + relation_output_values.push(Stage7StructuredPolynomialEvalPlan::from_cpu( symbol, string_attr(op, "polynomial")?, x_point, @@ -558,16 +558,19 @@ impl Stage7CpuProgram { )?); } "cpu.sumcheck_output_eval_family" => { - output_families.push(parse_output_eval_family_plan("stage7", op)?); + relation_output_eval_families + .push(parse_output_eval_family_plan("stage7", op)?); } "cpu.sumcheck_output_product_family" => { - output_product_families.push(parse_output_product_family_plan("stage7", op)?); + relation_output_product_families + .push(parse_output_product_family_plan("stage7", op)?); } "cpu.sumcheck_output_function_family" => { - output_function_families.push(parse_output_function_family_plan("stage7", op)?); + relation_output_function_families + .push(parse_output_function_family_plan("stage7", op)?); } "cpu.sumcheck_output_claim" => { - output_claim_asts.push(Stage7SumcheckOutputClaimAst { + relation_output_asts.push(Stage7RelationOutputAst { relation: symbol_attr(op, "relation")?, expected_output: operand_symbol(op, 0)?, polynomial_evals: symbol_array_attr(op, "polynomial_evals")?, @@ -637,23 +640,23 @@ impl Stage7CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if role == Role::Prover { - verifier_output_claims::prune_output_only_field_exprs( + verifier_relation_outputs::prune_output_only_field_exprs( &mut field_exprs, claims.iter().map(|claim| claim.claim_value.as_str()), - output_claim_asts + relation_output_asts .iter() .map(|claim| claim.expected_output.as_str()), ); } - let output_claims = if role == Role::Verifier { - verifier_output_claims::resolve_output_claims( + let relation_outputs = if role == Role::Verifier { + verifier_relation_outputs::resolve_relation_outputs( "stage7", - &output_values, - &output_families, - &output_product_families, - &output_function_families, + &relation_output_values, + &relation_output_eval_families, + &relation_output_product_families, + &relation_output_function_families, &field_exprs, - output_claim_asts, + relation_output_asts, )? } else { Vec::new() @@ -675,11 +678,11 @@ impl Stage7CpuProgram { drivers, instance_results, evals, - output_values, - output_families, - output_product_families, - output_function_families, - output_claims, + relation_output_values, + relation_output_eval_families, + relation_output_product_families, + relation_output_function_families, + relation_outputs, point_zeros, point_slices, point_concats, @@ -718,7 +721,7 @@ impl Stage7CpuProgram { Role::Verifier => self.verify_verifier_driver_bindings()?, } if self.role == Role::Verifier { - self.verify_output_claims()?; + self.verify_relation_outputs()?; } self.verify_opening_flow() } @@ -814,21 +817,25 @@ impl Stage7CpuProgram { verifier_values::VerifierScalarSourceKind::SumcheckEval, ); values.extend( - self.output_values.iter().map(|value| &value.symbol), + self.relation_output_values + .iter() + .map(|value| &value.symbol), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( - self.output_families.iter().map(|family| &family.symbol), + self.relation_output_eval_families + .iter() + .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( - self.output_product_families + self.relation_output_product_families .iter() .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); values.extend( - self.output_function_families + self.relation_output_function_families .iter() .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, @@ -1003,7 +1010,7 @@ impl Stage7CpuProgram { Ok(()) } - fn verify_output_claims(&self) -> Result<(), EmitError> { + fn verify_relation_outputs(&self) -> Result<(), EmitError> { let relations = symbols( self.instance_results .iter() @@ -1012,14 +1019,14 @@ impl Stage7CpuProgram { let plan = self.verifier_plan()?; let field_values = plan.scalar_value_sources(); let point_values = plan.point_value_sources(); - verifier_output_claims::verify_output_claims( + verifier_relation_outputs::verify_relation_outputs( "stage7", - verifier_output_claims::OutputClaimVerification { - output_values: &self.output_values, - output_families: &self.output_families, - output_product_families: &self.output_product_families, - output_function_families: &self.output_function_families, - output_claims: &self.output_claims, + verifier_relation_outputs::RelationOutputVerification { + relation_output_values: &self.relation_output_values, + relation_output_eval_families: &self.relation_output_eval_families, + relation_output_product_families: &self.relation_output_product_families, + relation_output_function_families: &self.relation_output_function_families, + relation_outputs: &self.relation_outputs, relations: &relations, field_values: &field_values, point_values: &point_values, @@ -1434,7 +1441,7 @@ pub type Stage7CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage7SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage7SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub type Stage7SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage7RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub type Stage7StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage7RelationKind; @@ -1497,11 +1504,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); source.push_str(&self.emit_sumcheck_batch_constants()?); source.push_str(&self.emit_sumcheck_driver_constants()?); if self.role == Role::Verifier { - source.push_str(&self.emit_verifier_output_claim_constants()?); + source.push_str(&self.emit_verifier_relation_output_constants()?); } source.push_str(&self.emit_tail_constants()?); - let output_claims_field = if self.role == Role::Verifier { - " output_claims: STAGE7_SUMCHECK_OUTPUT_CLAIMS,\n" + let relation_outputs_field = if self.role == Role::Verifier { + " relation_outputs: STAGE7_RELATION_OUTPUTS,\n" } else { "" }; @@ -1523,7 +1530,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); \x20 drivers: STAGE7_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE7_SUMCHECK_EVALS,\n\ - {output_claims_field}\ + {relation_outputs_field}\ \x20 point_zeros: STAGE7_POINT_ZEROS,\n\ \x20 point_slices: STAGE7_POINT_SLICES,\n\ \x20 point_concats: STAGE7_POINT_CONCATS,\n\ @@ -1999,11 +2006,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); ) } - fn emit_verifier_output_claim_constants(&self) -> Result { - super::output_claims::emit_verifier_output_claim_constants( + fn emit_verifier_relation_output_constants(&self) -> Result { + super::relation_outputs::emit_verifier_relation_output_constants( "Stage7", &self.role, - &self.output_claims, + &self.relation_outputs, ) } @@ -2502,8 +2509,8 @@ fn expected_batched_output_claim( }; let value = match relation { Stage7RelationKind::Stage7HammingWeightClaimReduction => { - bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index f494a5dda8..0262346423 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -8,8 +8,8 @@ pub(crate) mod stage5_instruction_read_raf_plan; pub(crate) mod stage6_bytecode_read_raf_plan; pub mod validate; pub(crate) mod verifier_eval_families; -pub(crate) mod verifier_output_claims; pub(crate) mod verifier_plan; +pub(crate) mod verifier_relation_outputs; pub(crate) mod verifier_values; pub use artifacts::{ diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 9f19c40965..c0206acc92 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -1,10 +1,10 @@ use crate::emit::rust::{push_format, EmitError}; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; -use crate::protocols::jolt::verifier_output_claims::{ +use crate::protocols::jolt::verifier_relation_outputs::{ + RelationOutputPlan, RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, StructuredPolynomialEvalPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment, SumcheckOutputClaimPlan, SumcheckOutputProductFamilyPlan, - SumcheckOutputProductFamilyTermPlan, + StructuredPolynomialPointSegment, }; pub(crate) const STAGE5_TABLE_FLAG_EVAL_FAMILY: &str = @@ -80,10 +80,10 @@ impl Stage5InstructionReadRafEmitPlan { source } - pub(crate) fn output_claim_plan(&self) -> Stage5InstructionReadRafOutputPlan { + pub(crate) fn relation_output_plan(&self) -> Stage5InstructionReadRafOutputPlan { const PREFIX: &str = "stage5.instruction_read_raf.output"; - let table_value_family = SumcheckOutputProductFamilyPlan { + let table_value_family = RelationOutputProductFamilyPlan { symbol: format!("{PREFIX}.product.LookupTableValues"), gamma: None, terms: self @@ -96,7 +96,7 @@ impl Stage5InstructionReadRafEmitPlan { .filter(|value| value.is_lookup_table()), ) .map( - |(flag_eval, table_value)| SumcheckOutputProductFamilyTermPlan { + |(flag_eval, table_value)| RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: vec![table_value.symbol.clone(), flag_eval.clone()], eval_families: Vec::new(), @@ -105,10 +105,10 @@ impl Stage5InstructionReadRafEmitPlan { ) .collect(), }; - let ra_product_family = SumcheckOutputProductFamilyPlan { + let ra_product_family = RelationOutputProductFamilyPlan { symbol: format!("{PREFIX}.product.InstructionRa"), gamma: None, - terms: vec![SumcheckOutputProductFamilyTermPlan { + terms: vec![RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: Vec::new(), eval_families: vec![self.instruction_ra_evals.symbol.clone()], @@ -203,7 +203,7 @@ impl Stage5InstructionReadRafEmitPlan { Stage5InstructionReadRafOutputPlan { field_exprs, - claim: SumcheckOutputClaimPlan { + claim: RelationOutputPlan { relation: "jolt.stage5.instruction_read_raf".to_owned(), polynomial_evals: vec![eq], eval_families: Vec::new(), @@ -229,7 +229,7 @@ pub(crate) struct Stage5InstructionReadRafPointValueEmitPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Stage5InstructionReadRafOutputPlan { pub(crate) field_exprs: Vec, - pub(crate) claim: SumcheckOutputClaimPlan, + pub(crate) claim: RelationOutputPlan, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -411,7 +411,7 @@ mod tests { } #[test] - fn instruction_read_raf_output_claim_plan_is_typed() -> Result<(), EmitError> { + fn instruction_read_raf_relation_output_plan_is_typed() -> Result<(), EmitError> { let families = instruction_read_raf_families([ ( "LookupTableFlag_0", @@ -427,7 +427,7 @@ mod tests { ), ]); let plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&families)?; - let output_plan = plan.output_claim_plan(); + let output_plan = plan.relation_output_plan(); assert_eq!( output_plan.claim.relation, diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index fb86e6c2b5..705d234d24 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -1,7 +1,7 @@ use crate::emit::rust::{push_format, EmitError}; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; -use crate::protocols::jolt::verifier_output_claims::{ - SumcheckOutputClaimPlan, SumcheckOutputProductFamilyPlan, SumcheckOutputProductFamilyTermPlan, +use crate::protocols::jolt::verifier_relation_outputs::{ + RelationOutputPlan, RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, }; pub(crate) const STAGE6_BYTECODE_RA_EVAL_FAMILY: &str = "stage6.bytecode_read_raf.eval.BytecodeRa"; @@ -336,28 +336,28 @@ pub(crate) fn stage6_bytecode_read_raf_output_contribution_symbol() -> &'static STAGE6_BYTECODE_READ_RAF_PLAN.output_contribution } -pub(crate) fn stage6_bytecode_read_raf_output_claim_plan( +pub(crate) fn stage6_bytecode_read_raf_relation_output_plan( bytecode_ra_evals: &IndexedEvalFamilyPlan, -) -> SumcheckOutputClaimPlan { - STAGE6_BYTECODE_READ_RAF_PLAN.output_claim_plan(bytecode_ra_evals) +) -> RelationOutputPlan { + STAGE6_BYTECODE_READ_RAF_PLAN.relation_output_plan(bytecode_ra_evals) } impl BytecodeReadRafPlan { - fn output_claim_plan( + fn relation_output_plan( &self, bytecode_ra_evals: &IndexedEvalFamilyPlan, - ) -> SumcheckOutputClaimPlan { - let product_family = SumcheckOutputProductFamilyPlan { + ) -> RelationOutputPlan { + let product_family = RelationOutputProductFamilyPlan { symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf".to_owned(), gamma: None, - terms: vec![SumcheckOutputProductFamilyTermPlan { + terms: vec![RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: vec![self.output_contribution.to_owned()], eval_families: vec![bytecode_ra_evals.symbol.clone()], factors: Vec::new(), }], }; - SumcheckOutputClaimPlan { + RelationOutputPlan { relation: "jolt.stage6.bytecode_read_raf".to_owned(), polynomial_evals: Vec::new(), eval_families: Vec::new(), @@ -567,8 +567,8 @@ mod tests { use super::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, - stage6_bytecode_read_raf_output_claim_plan, - stage6_bytecode_read_raf_output_contribution_symbol, BytecodeFlag, BytecodeOutputTermPlan, + stage6_bytecode_read_raf_output_contribution_symbol, + stage6_bytecode_read_raf_relation_output_plan, BytecodeFlag, BytecodeOutputTermPlan, BytecodeReadRafTermPlan, BytecodeRegister, STAGE6_BYTECODE_RA_EVAL_FAMILY, STAGE6_BYTECODE_READ_RAF_PLAN, }; @@ -673,9 +673,9 @@ mod tests { } #[test] - fn stage6_bytecode_output_claim_plan_uses_point_derived_contribution() { + fn stage6_bytecode_relation_output_plan_uses_point_derived_contribution() { let bytecode_ra_evals = bytecode_ra_evals(); - let claim = stage6_bytecode_read_raf_output_claim_plan(&bytecode_ra_evals); + let claim = stage6_bytecode_read_raf_relation_output_plan(&bytecode_ra_evals); assert_eq!(claim.relation, "jolt.stage6.bytecode_read_raf"); assert_eq!( diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 48f0f5e85d..e1d2f03c4f 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -7,9 +7,9 @@ use crate::protocols::jolt::rust_target_plan::{ RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, }; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; -use crate::protocols::jolt::verifier_output_claims::{ - StructuredPolynomialEvalPlan, SumcheckOutputClaimPlan, SumcheckOutputEvalFamilyPlan, - SumcheckOutputFunctionFamilyPlan, SumcheckOutputProductFamilyPlan, +use crate::protocols::jolt::verifier_relation_outputs::{ + RelationOutputEvalFamilyPlan, RelationOutputFunctionFamilyPlan, RelationOutputPlan, + RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan, }; use crate::protocols::jolt::verifier_values::{ VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarSourceKind, @@ -264,11 +264,11 @@ pub(crate) struct VerifierStagePlan { pub(crate) instance_results: Vec, pub(crate) sumcheck_evals: Vec, pub(crate) indexed_eval_families: Vec, - pub(crate) output_values: Vec, - pub(crate) output_families: Vec, - pub(crate) output_product_families: Vec, - pub(crate) output_function_families: Vec, - pub(crate) output_claims: Vec, + pub(crate) relation_output_values: Vec, + pub(crate) relation_output_eval_families: Vec, + pub(crate) relation_output_product_families: Vec, + pub(crate) relation_output_function_families: Vec, + pub(crate) relation_outputs: Vec, pub(crate) point_zeros: Vec, pub(crate) point_slices: Vec, pub(crate) point_concats: Vec, @@ -301,45 +301,49 @@ impl VerifierStagePlan { VerifierScalarSourceKind::TranscriptScalar, ); values.extend( - self.output_values.iter().map(|value| &value.symbol), + self.relation_output_values + .iter() + .map(|value| &value.symbol), VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( - self.output_families.iter().map(|family| &family.symbol), + self.relation_output_eval_families + .iter() + .map(|family| &family.symbol), VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( - self.output_product_families + self.relation_output_product_families .iter() .map(|family| &family.symbol), VerifierScalarSourceKind::OutputProductFamily, ); values.extend( - self.output_function_families + self.relation_output_function_families .iter() .map(|family| &family.symbol), VerifierScalarSourceKind::OutputFunctionFamily, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), VerifierScalarSourceKind::OutputEvalFamily, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), VerifierScalarSourceKind::OutputProductFamily, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), VerifierScalarSourceKind::OutputFunctionFamily, @@ -349,7 +353,7 @@ impl VerifierStagePlan { VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.output_claims + self.relation_outputs .iter() .flat_map(|claim| claim.local_scalars.iter()), VerifierScalarSourceKind::PointDerived, @@ -583,17 +587,17 @@ pub(crate) trait VerifierStagePlanSource { fn instance_results(&self) -> &[Self::Instance]; fn sumcheck_evals(&self) -> &[Self::Eval]; fn indexed_eval_families(&self) -> &[IndexedEvalFamilyPlan]; - fn output_values(&self) -> &[StructuredPolynomialEvalPlan]; - fn output_families(&self) -> &[SumcheckOutputEvalFamilyPlan] { + fn relation_output_values(&self) -> &[StructuredPolynomialEvalPlan]; + fn relation_output_eval_families(&self) -> &[RelationOutputEvalFamilyPlan] { &[] } - fn output_product_families(&self) -> &[SumcheckOutputProductFamilyPlan] { + fn relation_output_product_families(&self) -> &[RelationOutputProductFamilyPlan] { &[] } - fn output_function_families(&self) -> &[SumcheckOutputFunctionFamilyPlan] { + fn relation_output_function_families(&self) -> &[RelationOutputFunctionFamilyPlan] { &[] } - fn output_claims(&self) -> &[SumcheckOutputClaimPlan]; + fn relation_outputs(&self) -> &[RelationOutputPlan]; fn point_zeros(&self) -> Vec; fn point_slices(&self) -> &[Self::PointSlice]; fn point_concats(&self) -> &[Self::PointConcat]; @@ -746,11 +750,11 @@ where }) .collect(), indexed_eval_families: source.indexed_eval_families().to_vec(), - output_values: source.output_values().to_vec(), - output_families: source.output_families().to_vec(), - output_product_families: source.output_product_families().to_vec(), - output_function_families: source.output_function_families().to_vec(), - output_claims: source.output_claims().to_vec(), + relation_output_values: source.relation_output_values().to_vec(), + relation_output_eval_families: source.relation_output_eval_families().to_vec(), + relation_output_product_families: source.relation_output_product_families().to_vec(), + relation_output_function_families: source.relation_output_function_families().to_vec(), + relation_outputs: source.relation_outputs().to_vec(), point_zeros: source.point_zeros(), point_slices: source .point_slices() @@ -865,9 +869,9 @@ macro_rules! impl_verifier_plan_source_traits { $(, absorb = $absorb:ty)? $(, point_zero = $point_zero:ty)? $(, indexed_eval_families = $indexed_eval_families:ident)? - $(, output_families = $output_families:ident)? - $(, output_product_families = $output_product_families:ident)? - $(, output_function_families = $output_function_families:ident)? + $(, relation_output_eval_families = $relation_output_eval_families:ident)? + $(, relation_output_product_families = $relation_output_product_families:ident)? + $(, relation_output_function_families = $relation_output_function_families:ident)? $(,)? ) => { impl $crate::protocols::jolt::verifier_plan::VerifierStagePlanSource for $program { @@ -907,26 +911,26 @@ macro_rules! impl_verifier_plan_source_traits { @indexed_eval_families self $(, $indexed_eval_families)? ) } - fn output_values(&self) -> &[$crate::protocols::jolt::verifier_output_claims::StructuredPolynomialEvalPlan] { - &self.output_values + fn relation_output_values(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::StructuredPolynomialEvalPlan] { + &self.relation_output_values } - fn output_families(&self) -> &[$crate::protocols::jolt::verifier_output_claims::SumcheckOutputEvalFamilyPlan] { + fn relation_output_eval_families(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::RelationOutputEvalFamilyPlan] { $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( - @output_families self $(, $output_families)? + @relation_output_eval_families self $(, $relation_output_eval_families)? ) } - fn output_product_families(&self) -> &[$crate::protocols::jolt::verifier_output_claims::SumcheckOutputProductFamilyPlan] { + fn relation_output_product_families(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::RelationOutputProductFamilyPlan] { $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( - @output_product_families self $(, $output_product_families)? + @relation_output_product_families self $(, $relation_output_product_families)? ) } - fn output_function_families(&self) -> &[$crate::protocols::jolt::verifier_output_claims::SumcheckOutputFunctionFamilyPlan] { + fn relation_output_function_families(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::RelationOutputFunctionFamilyPlan] { $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( - @output_function_families self $(, $output_function_families)? + @relation_output_function_families self $(, $relation_output_function_families)? ) } - fn output_claims(&self) -> &[$crate::protocols::jolt::verifier_output_claims::SumcheckOutputClaimPlan] { - &self.output_claims + fn relation_outputs(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::RelationOutputPlan] { + &self.relation_outputs } fn point_zeros(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierPointZeroPlan> { $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( @@ -1110,22 +1114,22 @@ macro_rules! impl_verifier_plan_source_traits { (@indexed_eval_families $self:ident) => { &[] }; - (@output_families $self:ident, $output_families:ident) => { - &$self.$output_families + (@relation_output_eval_families $self:ident, $relation_output_eval_families:ident) => { + &$self.$relation_output_eval_families }; - (@output_families $self:ident) => { + (@relation_output_eval_families $self:ident) => { &[] }; - (@output_product_families $self:ident, $output_product_families:ident) => { - &$self.$output_product_families + (@relation_output_product_families $self:ident, $relation_output_product_families:ident) => { + &$self.$relation_output_product_families }; - (@output_product_families $self:ident) => { + (@relation_output_product_families $self:ident) => { &[] }; - (@output_function_families $self:ident, $output_function_families:ident) => { - &$self.$output_function_families + (@relation_output_function_families $self:ident, $relation_output_function_families:ident) => { + &$self.$relation_output_function_families }; - (@output_function_families $self:ident) => { + (@relation_output_function_families $self:ident) => { &[] }; } diff --git a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs similarity index 74% rename from crates/bolt/src/protocols/jolt/verifier_output_claims.rs rename to crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index e4f8a14c69..eecb1f1594 100644 --- a/crates/bolt/src/protocols/jolt/verifier_output_claims.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -118,11 +118,11 @@ impl StructuredPolynomialPointOrder { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum SumcheckOutputFunctionKind { +pub enum RelationOutputFunctionKind { BooleanZero, } -impl SumcheckOutputFunctionKind { +impl RelationOutputFunctionKind { pub fn as_str(self) -> &'static str { match self { Self::BooleanZero => "boolean_zero", @@ -133,13 +133,13 @@ impl SumcheckOutputFunctionKind { match value { "boolean_zero" => Ok(Self::BooleanZero), _ => Err(EmitError::new(format!( - "unsupported output function `{value}`" + "unsupported relation output function `{value}`" ))), } } } -impl PartialEq<&str> for SumcheckOutputFunctionKind { +impl PartialEq<&str> for RelationOutputFunctionKind { fn eq(&self, other: &&str) -> bool { matches!((self, *other), (Self::BooleanZero, "boolean_zero")) } @@ -194,30 +194,30 @@ impl StructuredPolynomialEvalPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputEvalFamilySharedTermPlan { +pub struct RelationOutputEvalFamilySharedTermPlan { pub gamma_power_offset: usize, pub factor: String, } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputEvalFamilyItemTermPlan { +pub struct RelationOutputEvalFamilyItemTermPlan { pub gamma_power_offset: usize, pub factors: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputEvalFamilyPlan { +pub struct RelationOutputEvalFamilyPlan { pub symbol: String, pub gamma: String, pub evals: Vec, pub power_stride: usize, pub value_term_offsets: Vec, - pub shared_terms: Vec, - pub item_terms: Vec, + pub shared_terms: Vec, + pub item_terms: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputProductFamilyTermPlan { +pub struct RelationOutputProductFamilyTermPlan { pub gamma_power_offset: usize, pub evals: Vec, pub eval_families: Vec, @@ -225,40 +225,40 @@ pub struct SumcheckOutputProductFamilyTermPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputProductFamilyPlan { +pub struct RelationOutputProductFamilyPlan { pub symbol: String, pub gamma: Option, - pub terms: Vec, + pub terms: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputFunctionFamilyTermPlan { +pub struct RelationOutputFunctionFamilyTermPlan { pub gamma_power_offset: usize, - pub function: SumcheckOutputFunctionKind, + pub function: RelationOutputFunctionKind, pub eval: String, pub factors: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputFunctionFamilyPlan { +pub struct RelationOutputFunctionFamilyPlan { pub symbol: String, pub gamma: Option, - pub terms: Vec, + pub terms: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputClaimPlan { +pub struct RelationOutputPlan { pub relation: String, pub polynomial_evals: Vec, - pub eval_families: Vec, - pub product_families: Vec, - pub function_families: Vec, + pub eval_families: Vec, + pub product_families: Vec, + pub function_families: Vec, pub local_scalars: Vec, pub expected_output: String, } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct SumcheckOutputClaimAst { +pub struct RelationOutputAst { pub relation: String, pub polynomial_evals: Vec, pub polynomial_eval_operands: Vec, @@ -268,7 +268,7 @@ pub struct SumcheckOutputClaimAst { pub fn parse_output_eval_family_plan( stage: &str, operation: OperationRef<'_, '_>, -) -> Result { +) -> Result { let symbol = string_attr(operation, "sym_name")?; let evals = symbol_array_attr(operation, "evals")?; let shared_factors = symbol_array_attr(operation, "shared_terms")?; @@ -277,13 +277,13 @@ pub fn parse_output_eval_family_plan( let shared_term_offsets = int_array_attr(operation, "shared_term_offsets")?; let item_term_offsets = int_array_attr(operation, "item_term_offsets")?; verify_count( - "output eval family shared terms", + "relation output eval family shared terms", &symbol, shared_term_offsets.len(), shared_factors.len(), )?; verify_count( - "output eval family item term factors", + "relation output eval family item term factors", &symbol, item_term_offsets.len() * evals.len(), item_factors.len(), @@ -292,7 +292,7 @@ pub fn parse_output_eval_family_plan( let eval_operands = operand_symbols(operation, 1, 1 + evals.len())?; if evals != eval_operands { return Err(EmitError::new(format!( - "{stage} output eval family @{symbol} evals do not match operands" + "{stage} relation output eval family @{symbol} evals do not match operands" ))); } let shared_start = 1 + evals.len(); @@ -300,20 +300,20 @@ pub fn parse_output_eval_family_plan( let shared_operands = operand_symbols(operation, shared_start, shared_end)?; if shared_factors != shared_operands { return Err(EmitError::new(format!( - "{stage} output eval family @{symbol} shared_terms do not match operands" + "{stage} relation output eval family @{symbol} shared_terms do not match operands" ))); } let item_operands = operand_symbols(operation, shared_end, operation.operand_count())?; if item_factors != item_operands { return Err(EmitError::new(format!( - "{stage} output eval family @{symbol} item_terms do not match operands" + "{stage} relation output eval family @{symbol} item_terms do not match operands" ))); } let shared_terms = shared_term_offsets .into_iter() .zip(shared_factors) .map( - |(gamma_power_offset, factor)| SumcheckOutputEvalFamilySharedTermPlan { + |(gamma_power_offset, factor)| RelationOutputEvalFamilySharedTermPlan { gamma_power_offset, factor, }, @@ -323,12 +323,12 @@ pub fn parse_output_eval_family_plan( for (term_index, gamma_power_offset) in item_term_offsets.into_iter().enumerate() { let start = term_index * evals.len(); let end = start + evals.len(); - item_terms.push(SumcheckOutputEvalFamilyItemTermPlan { + item_terms.push(RelationOutputEvalFamilyItemTermPlan { gamma_power_offset, factors: item_factors[start..end].to_vec(), }); } - Ok(SumcheckOutputEvalFamilyPlan { + Ok(RelationOutputEvalFamilyPlan { symbol, gamma, evals, @@ -342,7 +342,7 @@ pub fn parse_output_eval_family_plan( pub fn parse_output_product_family_plan( stage: &str, operation: OperationRef<'_, '_>, -) -> Result { +) -> Result { let symbol = string_attr(operation, "sym_name")?; let gamma = optional_symbol_array_attr(operation, "gamma")?; let evals = symbol_array_attr(operation, "evals")?; @@ -351,25 +351,25 @@ pub fn parse_output_product_family_plan( let term_eval_counts = int_array_attr(operation, "term_eval_counts")?; let term_factor_counts = int_array_attr(operation, "term_factor_counts")?; verify_count( - "output product family term eval counts", + "relation output product family term eval counts", &symbol, term_gamma_power_offsets.len(), term_eval_counts.len(), )?; verify_count( - "output product family term factor counts", + "relation output product family term factor counts", &symbol, term_gamma_power_offsets.len(), term_factor_counts.len(), )?; verify_count( - "output product family evals", + "relation output product family evals", &symbol, term_eval_counts.iter().sum(), evals.len(), )?; verify_count( - "output product family factors", + "relation output product family factors", &symbol, term_factor_counts.iter().sum(), factors.len(), @@ -379,7 +379,7 @@ pub fn parse_output_product_family_plan( let gamma_operand = operand_symbol(operation, 0)?; if gamma_operand != *gamma_symbol { return Err(EmitError::new(format!( - "{stage} output product family @{symbol} gamma does not match operand" + "{stage} relation output product family @{symbol} gamma does not match operand" ))); } } @@ -387,13 +387,13 @@ pub fn parse_output_product_family_plan( let eval_operands = operand_symbols(operation, eval_start, eval_end)?; if evals != eval_operands { return Err(EmitError::new(format!( - "{stage} output product family @{symbol} evals do not match operands" + "{stage} relation output product family @{symbol} evals do not match operands" ))); } let factor_operands = operand_symbols(operation, eval_end, operation.operand_count())?; if factors != factor_operands { return Err(EmitError::new(format!( - "{stage} output product family @{symbol} factors do not match operands" + "{stage} relation output product family @{symbol} factors do not match operands" ))); } let mut eval_offset = 0; @@ -406,12 +406,12 @@ pub fn parse_output_product_family_plan( { if eval_count == 0 && factor_count == 0 { return Err(EmitError::new(format!( - "{stage} output product family @{symbol} has an empty term" + "{stage} relation output product family @{symbol} has an empty term" ))); } let eval_end = eval_offset + eval_count; let factor_end = factor_offset + factor_count; - terms.push(SumcheckOutputProductFamilyTermPlan { + terms.push(RelationOutputProductFamilyTermPlan { gamma_power_offset, evals: evals[eval_offset..eval_end].to_vec(), eval_families: Vec::new(), @@ -420,7 +420,7 @@ pub fn parse_output_product_family_plan( eval_offset = eval_end; factor_offset = factor_end; } - Ok(SumcheckOutputProductFamilyPlan { + Ok(RelationOutputProductFamilyPlan { symbol, gamma: gamma.into_iter().next(), terms, @@ -430,7 +430,7 @@ pub fn parse_output_product_family_plan( pub fn parse_output_function_family_plan( stage: &str, operation: OperationRef<'_, '_>, -) -> Result { +) -> Result { let symbol = string_attr(operation, "sym_name")?; let gamma = optional_symbol_array_attr(operation, "gamma")?; let evals = symbol_array_attr(operation, "evals")?; @@ -439,25 +439,25 @@ pub fn parse_output_function_family_plan( let term_functions = string_array_attr(operation, "term_functions")?; let term_factor_counts = int_array_attr(operation, "term_factor_counts")?; verify_count( - "output function family term functions", + "relation output function family term functions", &symbol, term_gamma_power_offsets.len(), term_functions.len(), )?; verify_count( - "output function family term factor counts", + "relation output function family term factor counts", &symbol, term_gamma_power_offsets.len(), term_factor_counts.len(), )?; verify_count( - "output function family evals", + "relation output function family evals", &symbol, term_gamma_power_offsets.len(), evals.len(), )?; verify_count( - "output function family factors", + "relation output function family factors", &symbol, term_factor_counts.iter().sum(), factors.len(), @@ -467,7 +467,7 @@ pub fn parse_output_function_family_plan( let gamma_operand = operand_symbol(operation, 0)?; if gamma_operand != *gamma_symbol { return Err(EmitError::new(format!( - "{stage} output function family @{symbol} gamma does not match operand" + "{stage} relation output function family @{symbol} gamma does not match operand" ))); } } @@ -475,13 +475,13 @@ pub fn parse_output_function_family_plan( let eval_operands = operand_symbols(operation, eval_start, eval_end)?; if evals != eval_operands { return Err(EmitError::new(format!( - "{stage} output function family @{symbol} evals do not match operands" + "{stage} relation output function family @{symbol} evals do not match operands" ))); } let factor_operands = operand_symbols(operation, eval_end, operation.operand_count())?; if factors != factor_operands { return Err(EmitError::new(format!( - "{stage} output function family @{symbol} factors do not match operands" + "{stage} relation output function family @{symbol} factors do not match operands" ))); } let mut factor_offset = 0; @@ -493,17 +493,19 @@ pub fn parse_output_function_family_plan( .zip(term_factor_counts) { let factor_end = factor_offset + factor_count; - terms.push(SumcheckOutputFunctionFamilyTermPlan { + terms.push(RelationOutputFunctionFamilyTermPlan { gamma_power_offset, - function: SumcheckOutputFunctionKind::from_cpu_attr(&function).map_err(|error| { - EmitError::new(format!("{stage} output function family @{symbol}: {error}")) + function: RelationOutputFunctionKind::from_cpu_attr(&function).map_err(|error| { + EmitError::new(format!( + "{stage} relation output function family @{symbol}: {error}" + )) })?, eval, factors: factors[factor_offset..factor_end].to_vec(), }); factor_offset = factor_end; } - Ok(SumcheckOutputFunctionFamilyPlan { + Ok(RelationOutputFunctionFamilyPlan { symbol, gamma: gamma.into_iter().next(), terms, @@ -515,34 +517,36 @@ pub trait FieldExprDependencies { fn operands(&self) -> &[String]; } -pub fn resolve_output_claims( +pub fn resolve_relation_outputs( stage: &str, - output_values: &[StructuredPolynomialEvalPlan], - output_families: &[SumcheckOutputEvalFamilyPlan], - output_product_families: &[SumcheckOutputProductFamilyPlan], - output_function_families: &[SumcheckOutputFunctionFamilyPlan], + relation_output_values: &[StructuredPolynomialEvalPlan], + relation_output_eval_families: &[RelationOutputEvalFamilyPlan], + relation_output_product_families: &[RelationOutputProductFamilyPlan], + relation_output_function_families: &[RelationOutputFunctionFamilyPlan], field_exprs: &[T], - claim_asts: Vec, -) -> Result, EmitError> + claim_asts: Vec, +) -> Result, EmitError> where T: FieldExprDependencies, { - let output_values_by_symbol: BTreeMap<_, _> = output_values + let relation_output_values_by_symbol: BTreeMap<_, _> = relation_output_values .iter() .map(|value| (value.symbol.as_str(), value)) .collect(); - let output_families_by_symbol: BTreeMap<_, _> = output_families - .iter() - .map(|family| (family.symbol.as_str(), family)) - .collect(); - let output_product_families_by_symbol: BTreeMap<_, _> = output_product_families - .iter() - .map(|family| (family.symbol.as_str(), family)) - .collect(); - let output_function_families_by_symbol: BTreeMap<_, _> = output_function_families + let relation_output_eval_families_by_symbol: BTreeMap<_, _> = relation_output_eval_families .iter() .map(|family| (family.symbol.as_str(), family)) .collect(); + let relation_output_product_families_by_symbol: BTreeMap<_, _> = + relation_output_product_families + .iter() + .map(|family| (family.symbol.as_str(), family)) + .collect(); + let relation_output_function_families_by_symbol: BTreeMap<_, _> = + relation_output_function_families + .iter() + .map(|family| (family.symbol.as_str(), family)) + .collect(); let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs .iter() .map(|expr| (expr.symbol(), expr)) @@ -551,14 +555,14 @@ where .into_iter() .map(|claim| { verify_count( - "sumcheck output claim polynomial_evals", + "relation output polynomial_evals", &claim.relation, claim.polynomial_evals.len(), claim.polynomial_eval_operands.len(), )?; if claim.polynomial_evals != claim.polynomial_eval_operands { return Err(EmitError::new(format!( - "{stage} output claim for @{} polynomial_evals do not match operands", + "{stage} relation output for @{} polynomial_evals do not match operands", claim.relation ))); } @@ -566,41 +570,41 @@ where .polynomial_evals .iter() .map(|symbol| { - output_values_by_symbol + relation_output_values_by_symbol .get(symbol.as_str()) .copied() .cloned() .ok_or_else(|| { EmitError::new(format!( - "{stage} output claim for @{} references missing output value @{symbol}", + "{stage} relation output for @{} references missing output value @{symbol}", claim.relation )) }) }) .collect::, EmitError>>()?; let dependencies = output_dependency_closure( - &output_families_by_symbol, - &output_product_families_by_symbol, - &output_function_families_by_symbol, + &relation_output_eval_families_by_symbol, + &relation_output_product_families_by_symbol, + &relation_output_function_families_by_symbol, &field_exprs_by_symbol, std::iter::once(claim.expected_output.as_str()), ); - let eval_families = output_families + let eval_families = relation_output_eval_families .iter() .filter(|family| dependencies.contains_eval_family(&family.symbol)) .cloned() .collect(); - let product_families = output_product_families + let product_families = relation_output_product_families .iter() .filter(|family| dependencies.contains_product_family(&family.symbol)) .cloned() .collect(); - let function_families = output_function_families + let function_families = relation_output_function_families .iter() .filter(|family| dependencies.contains_function_family(&family.symbol)) .cloned() .collect(); - Ok(SumcheckOutputClaimPlan { + Ok(RelationOutputPlan { relation: claim.relation, polynomial_evals, eval_families, @@ -655,9 +659,9 @@ impl OutputDependencyClosure { } fn output_dependency_closure<'a, T>( - output_families_by_symbol: &BTreeMap<&str, &SumcheckOutputEvalFamilyPlan>, - output_product_families_by_symbol: &BTreeMap<&str, &SumcheckOutputProductFamilyPlan>, - output_function_families_by_symbol: &BTreeMap<&str, &SumcheckOutputFunctionFamilyPlan>, + relation_output_eval_families_by_symbol: &BTreeMap<&str, &RelationOutputEvalFamilyPlan>, + relation_output_product_families_by_symbol: &BTreeMap<&str, &RelationOutputProductFamilyPlan>, + relation_output_function_families_by_symbol: &BTreeMap<&str, &RelationOutputFunctionFamilyPlan>, field_exprs_by_symbol: &BTreeMap<&str, &T>, roots: impl Iterator, ) -> OutputDependencyClosure @@ -669,9 +673,9 @@ where let mut stack = roots .map(|symbol| { output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, symbol, ) @@ -689,42 +693,43 @@ where }; stack.extend(expr.operands().iter().map(|operand| { output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, operand, ) })); } OutputDependencyNode::EvalFamily(symbol) => { - let Some(family) = output_families_by_symbol.get(symbol.as_str()) else { + let Some(family) = relation_output_eval_families_by_symbol.get(symbol.as_str()) + else { continue; }; let _inserted = dependencies .families .insert(OutputFamilyDependency::Eval(family.symbol.clone())); stack.push(output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, &family.gamma, )); stack.extend(family.evals.iter().map(|eval| { output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, eval, ) })); stack.extend(family.shared_terms.iter().map(|term| { output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, &term.factor, ) @@ -732,9 +737,9 @@ where stack.extend(family.item_terms.iter().flat_map(|term| { term.factors.iter().map(|factor| { output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, factor, ) @@ -742,7 +747,8 @@ where })); } OutputDependencyNode::ProductFamily(symbol) => { - let Some(family) = output_product_families_by_symbol.get(symbol.as_str()) else { + let Some(family) = relation_output_product_families_by_symbol.get(symbol.as_str()) + else { continue; }; let _inserted = dependencies @@ -750,9 +756,9 @@ where .insert(OutputFamilyDependency::Product(family.symbol.clone())); stack.extend(family.gamma.iter().map(|gamma| { output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, gamma, ) @@ -760,18 +766,18 @@ where for term in &family.terms { stack.extend(term.evals.iter().map(|eval| { output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, eval, ) })); stack.extend(term.factors.iter().map(|factor| { output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, factor, ) @@ -779,7 +785,8 @@ where } } OutputDependencyNode::FunctionFamily(symbol) => { - let Some(family) = output_function_families_by_symbol.get(symbol.as_str()) else { + let Some(family) = relation_output_function_families_by_symbol.get(symbol.as_str()) + else { continue; }; let _inserted = dependencies @@ -787,26 +794,26 @@ where .insert(OutputFamilyDependency::Function(family.symbol.clone())); stack.extend(family.gamma.iter().map(|gamma| { output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, gamma, ) })); for term in &family.terms { stack.push(output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, &term.eval, )); stack.extend(term.factors.iter().map(|factor| { output_dependency_node( - output_families_by_symbol, - output_product_families_by_symbol, - output_function_families_by_symbol, + relation_output_eval_families_by_symbol, + relation_output_product_families_by_symbol, + relation_output_function_families_by_symbol, field_exprs_by_symbol, factor, ) @@ -819,17 +826,17 @@ where } fn output_dependency_node( - output_families_by_symbol: &BTreeMap<&str, &SumcheckOutputEvalFamilyPlan>, - output_product_families_by_symbol: &BTreeMap<&str, &SumcheckOutputProductFamilyPlan>, - output_function_families_by_symbol: &BTreeMap<&str, &SumcheckOutputFunctionFamilyPlan>, + relation_output_eval_families_by_symbol: &BTreeMap<&str, &RelationOutputEvalFamilyPlan>, + relation_output_product_families_by_symbol: &BTreeMap<&str, &RelationOutputProductFamilyPlan>, + relation_output_function_families_by_symbol: &BTreeMap<&str, &RelationOutputFunctionFamilyPlan>, field_exprs_by_symbol: &BTreeMap<&str, &impl FieldExprDependencies>, symbol: &str, ) -> OutputDependencyNode { - if output_families_by_symbol.contains_key(symbol) { + if relation_output_eval_families_by_symbol.contains_key(symbol) { OutputDependencyNode::EvalFamily(symbol.to_owned()) - } else if output_product_families_by_symbol.contains_key(symbol) { + } else if relation_output_product_families_by_symbol.contains_key(symbol) { OutputDependencyNode::ProductFamily(symbol.to_owned()) - } else if output_function_families_by_symbol.contains_key(symbol) { + } else if relation_output_function_families_by_symbol.contains_key(symbol) { OutputDependencyNode::FunctionFamily(symbol.to_owned()) } else if field_exprs_by_symbol.contains_key(symbol) { OutputDependencyNode::FieldExpr(symbol.to_owned()) @@ -841,7 +848,7 @@ fn output_dependency_node( pub fn prune_output_only_field_exprs<'a, 'b, T>( field_exprs: &mut Vec, sumcheck_claim_roots: impl Iterator, - output_claim_roots: impl Iterator, + relation_output_roots: impl Iterator, ) where T: FieldExprDependencies, { @@ -851,42 +858,42 @@ pub fn prune_output_only_field_exprs<'a, 'b, T>( .collect(); let sumcheck_claim_closure = field_expr_dependency_closure(&field_exprs_by_symbol, sumcheck_claim_roots); - let output_claim_closure = - field_expr_dependency_closure(&field_exprs_by_symbol, output_claim_roots); + let relation_output_closure = + field_expr_dependency_closure(&field_exprs_by_symbol, relation_output_roots); field_exprs.retain(|expr| { - !output_claim_closure.contains(expr.symbol()) + !relation_output_closure.contains(expr.symbol()) || sumcheck_claim_closure.contains(expr.symbol()) }); } -pub struct OutputClaimVerification<'a> { - pub output_values: &'a [StructuredPolynomialEvalPlan], - pub output_families: &'a [SumcheckOutputEvalFamilyPlan], - pub output_product_families: &'a [SumcheckOutputProductFamilyPlan], - pub output_function_families: &'a [SumcheckOutputFunctionFamilyPlan], - pub output_claims: &'a [SumcheckOutputClaimPlan], +pub struct RelationOutputVerification<'a> { + pub relation_output_values: &'a [StructuredPolynomialEvalPlan], + pub relation_output_eval_families: &'a [RelationOutputEvalFamilyPlan], + pub relation_output_product_families: &'a [RelationOutputProductFamilyPlan], + pub relation_output_function_families: &'a [RelationOutputFunctionFamilyPlan], + pub relation_outputs: &'a [RelationOutputPlan], pub relations: &'a BTreeSet, pub field_values: &'a VerifierScalarSourceSet, pub point_values: &'a VerifierPointSourceSet, } -pub fn verify_output_claims( +pub fn verify_relation_outputs( stage: &str, - verification: OutputClaimVerification<'_>, + verification: RelationOutputVerification<'_>, ) -> Result<(), EmitError> { - let OutputClaimVerification { - output_values, - output_families, - output_product_families, - output_function_families, - output_claims, + let RelationOutputVerification { + relation_output_values, + relation_output_eval_families, + relation_output_product_families, + relation_output_function_families, + relation_outputs, relations, field_values, point_values, } = verification; field_values.verify_no_conflicts(stage)?; point_values.verify_no_conflicts(stage)?; - for polynomial_eval in output_values { + for polynomial_eval in relation_output_values { if !point_values.contains(&polynomial_eval.x_point.source) { return Err(EmitError::new(format!( "{stage} structured polynomial eval @{} references missing x-point @{}", @@ -900,17 +907,17 @@ pub fn verify_output_claims( ))); } } - for family in output_families { + for family in relation_output_eval_families { if !field_values.contains(&family.gamma) { return Err(EmitError::new(format!( - "{stage} output eval family @{} references missing gamma @{}", + "{stage} relation output eval family @{} references missing gamma @{}", family.symbol, family.gamma ))); } for eval in &family.evals { if !field_values.contains(eval) { return Err(EmitError::new(format!( - "{stage} output eval family @{} references missing eval @{}", + "{stage} relation output eval family @{} references missing eval @{}", family.symbol, eval ))); } @@ -918,14 +925,14 @@ pub fn verify_output_claims( for term in &family.shared_terms { if !field_values.contains(&term.factor) { return Err(EmitError::new(format!( - "{stage} output eval family @{} references missing shared factor @{}", + "{stage} relation output eval family @{} references missing shared factor @{}", family.symbol, term.factor ))); } } for term in &family.item_terms { verify_count( - "output eval family item factors", + "relation output eval family item factors", &family.symbol, family.evals.len(), term.factors.len(), @@ -933,18 +940,18 @@ pub fn verify_output_claims( for factor in &term.factors { if !field_values.contains(factor) { return Err(EmitError::new(format!( - "{stage} output eval family @{} references missing item factor @{}", + "{stage} relation output eval family @{} references missing item factor @{}", family.symbol, factor ))); } } } } - for family in output_product_families { + for family in relation_output_product_families { if let Some(gamma) = &family.gamma { if !field_values.contains(gamma) { return Err(EmitError::new(format!( - "{stage} output product family @{} references missing gamma @{}", + "{stage} relation output product family @{} references missing gamma @{}", family.symbol, gamma ))); } @@ -952,14 +959,14 @@ pub fn verify_output_claims( for term in &family.terms { if term.evals.is_empty() && term.factors.is_empty() { return Err(EmitError::new(format!( - "{stage} output product family @{} has an empty term", + "{stage} relation output product family @{} has an empty term", family.symbol ))); } for eval in &term.evals { if !field_values.contains(eval) { return Err(EmitError::new(format!( - "{stage} output product family @{} references missing eval @{}", + "{stage} relation output product family @{} references missing eval @{}", family.symbol, eval ))); } @@ -967,18 +974,18 @@ pub fn verify_output_claims( for factor in &term.factors { if !field_values.contains(factor) { return Err(EmitError::new(format!( - "{stage} output product family @{} references missing factor @{}", + "{stage} relation output product family @{} references missing factor @{}", family.symbol, factor ))); } } } } - for family in output_function_families { + for family in relation_output_function_families { if let Some(gamma) = &family.gamma { if !field_values.contains(gamma) { return Err(EmitError::new(format!( - "{stage} output function family @{} references missing gamma @{}", + "{stage} relation output function family @{} references missing gamma @{}", family.symbol, gamma ))); } @@ -986,30 +993,30 @@ pub fn verify_output_claims( for term in &family.terms { if !field_values.contains(&term.eval) { return Err(EmitError::new(format!( - "{stage} output function family @{} references missing eval @{}", + "{stage} relation output function family @{} references missing eval @{}", family.symbol, term.eval ))); } for factor in &term.factors { if !field_values.contains(factor) { return Err(EmitError::new(format!( - "{stage} output function family @{} references missing factor @{}", + "{stage} relation output function family @{} references missing factor @{}", family.symbol, factor ))); } } } } - for claim in output_claims { + for claim in relation_outputs { if !relations.contains(&claim.relation) { return Err(EmitError::new(format!( - "{stage} output claim references missing relation @{}", + "{stage} relation output references missing relation @{}", claim.relation ))); } if !field_values.contains(&claim.expected_output) { return Err(EmitError::new(format!( - "{stage} output claim for @{} uses missing expected output @{}", + "{stage} relation output for @{} uses missing expected output @{}", claim.relation, claim.expected_output ))); } @@ -1208,12 +1215,12 @@ mod tests { }; use super::{ - resolve_output_claims, verify_output_claims, FieldExprDependencies, - OutputClaimVerification, SumcheckOutputClaimAst, SumcheckOutputEvalFamilyItemTermPlan, - SumcheckOutputEvalFamilyPlan, SumcheckOutputEvalFamilySharedTermPlan, - SumcheckOutputFunctionFamilyPlan, SumcheckOutputFunctionFamilyTermPlan, - SumcheckOutputFunctionKind, SumcheckOutputProductFamilyPlan, - SumcheckOutputProductFamilyTermPlan, + resolve_relation_outputs, verify_relation_outputs, FieldExprDependencies, + RelationOutputAst, RelationOutputEvalFamilyItemTermPlan, RelationOutputEvalFamilyPlan, + RelationOutputEvalFamilySharedTermPlan, RelationOutputFunctionFamilyPlan, + RelationOutputFunctionFamilyTermPlan, RelationOutputFunctionKind, + RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, + RelationOutputVerification, }; struct TestFieldExpr { @@ -1232,8 +1239,9 @@ mod tests { } #[test] - fn resolves_output_families_reachable_through_field_expressions() -> Result<(), EmitError> { - let inner_family = SumcheckOutputEvalFamilyPlan { + fn resolves_relation_output_eval_families_reachable_through_field_expressions( + ) -> Result<(), EmitError> { + let inner_family = RelationOutputEvalFamilyPlan { symbol: "inner.family".to_owned(), gamma: "inner.gamma".to_owned(), evals: vec!["inner.eval".to_owned()], @@ -1242,17 +1250,17 @@ mod tests { shared_terms: Vec::new(), item_terms: Vec::new(), }; - let outer_family = SumcheckOutputEvalFamilyPlan { + let outer_family = RelationOutputEvalFamilyPlan { symbol: "outer.family".to_owned(), gamma: "outer.gamma".to_owned(), evals: vec!["outer.eval".to_owned()], power_stride: 1, value_term_offsets: Vec::new(), - shared_terms: vec![SumcheckOutputEvalFamilySharedTermPlan { + shared_terms: vec![RelationOutputEvalFamilySharedTermPlan { gamma_power_offset: 0, factor: "outer.shared.factor".to_owned(), }], - item_terms: vec![SumcheckOutputEvalFamilyItemTermPlan { + item_terms: vec![RelationOutputEvalFamilyItemTermPlan { gamma_power_offset: 1, factors: vec!["factor.expr".to_owned()], }], @@ -1267,14 +1275,14 @@ mod tests { operands: vec!["inner.family".to_owned()], }, ]; - let claim_asts = vec![SumcheckOutputClaimAst { + let claim_asts = vec![RelationOutputAst { relation: "relation".to_owned(), polynomial_evals: Vec::new(), polynomial_eval_operands: Vec::new(), expected_output: "claim.expr".to_owned(), }]; - let claims = resolve_output_claims( + let claims = resolve_relation_outputs( "test", &[], &[inner_family, outer_family], @@ -1285,7 +1293,7 @@ mod tests { )?; let claim = claims .first() - .ok_or_else(|| EmitError::new("missing resolved output claim"))?; + .ok_or_else(|| EmitError::new("missing resolved relation output"))?; let family_symbols = claim .eval_families .iter() @@ -1299,10 +1307,10 @@ mod tests { #[test] fn resolves_product_families_reachable_through_field_expressions() -> Result<(), EmitError> { - let product_family = SumcheckOutputProductFamilyPlan { + let product_family = RelationOutputProductFamilyPlan { symbol: "product.family".to_owned(), gamma: Some("product.gamma".to_owned()), - terms: vec![SumcheckOutputProductFamilyTermPlan { + terms: vec![RelationOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: vec!["product.eval".to_owned()], eval_families: Vec::new(), @@ -1319,14 +1327,14 @@ mod tests { operands: vec!["unrelated.scalar".to_owned()], }, ]; - let claim_asts = vec![SumcheckOutputClaimAst { + let claim_asts = vec![RelationOutputAst { relation: "relation".to_owned(), polynomial_evals: Vec::new(), polynomial_eval_operands: Vec::new(), expected_output: "claim.expr".to_owned(), }]; - let claims = resolve_output_claims( + let claims = resolve_relation_outputs( "test", &[], &[], @@ -1337,7 +1345,7 @@ mod tests { )?; let claim = claims .first() - .ok_or_else(|| EmitError::new("missing resolved output claim"))?; + .ok_or_else(|| EmitError::new("missing resolved relation output"))?; assert!(claim.eval_families.is_empty()); let family_symbols = claim .product_families @@ -1351,12 +1359,12 @@ mod tests { #[test] fn resolves_function_families_reachable_through_field_expressions() -> Result<(), EmitError> { - let function_family = SumcheckOutputFunctionFamilyPlan { + let function_family = RelationOutputFunctionFamilyPlan { symbol: "function.family".to_owned(), gamma: Some("function.gamma".to_owned()), - terms: vec![SumcheckOutputFunctionFamilyTermPlan { + terms: vec![RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 0, - function: SumcheckOutputFunctionKind::BooleanZero, + function: RelationOutputFunctionKind::BooleanZero, eval: "function.eval".to_owned(), factors: vec!["function.factor.expr".to_owned()], }], @@ -1371,14 +1379,14 @@ mod tests { operands: vec!["unrelated.scalar".to_owned()], }, ]; - let claim_asts = vec![SumcheckOutputClaimAst { + let claim_asts = vec![RelationOutputAst { relation: "relation".to_owned(), polynomial_evals: Vec::new(), polynomial_eval_operands: Vec::new(), expected_output: "claim.expr".to_owned(), }]; - let claims = resolve_output_claims( + let claims = resolve_relation_outputs( "test", &[], &[], @@ -1389,7 +1397,7 @@ mod tests { )?; let claim = claims .first() - .ok_or_else(|| EmitError::new("missing resolved output claim"))?; + .ok_or_else(|| EmitError::new("missing resolved relation output"))?; assert!(claim.eval_families.is_empty()); assert!(claim.product_families.is_empty()); let family_symbols = claim @@ -1402,21 +1410,21 @@ mod tests { } #[test] - fn output_claim_verification_rejects_conflicting_scalar_sources() -> Result<(), EmitError> { + fn relation_output_verification_rejects_conflicting_scalar_sources() -> Result<(), EmitError> { let mut field_values = VerifierScalarSourceSet::default(); field_values.insert("value", VerifierScalarSourceKind::OpeningInput); field_values.insert("value", VerifierScalarSourceKind::FieldExpr); let point_values = VerifierPointSourceSet::default(); let relations = BTreeSet::new(); - let error = match verify_output_claims( + let error = match verify_relation_outputs( "stage", - OutputClaimVerification { - output_values: &[], - output_families: &[], - output_product_families: &[], - output_function_families: &[], - output_claims: &[], + RelationOutputVerification { + relation_output_values: &[], + relation_output_eval_families: &[], + relation_output_product_families: &[], + relation_output_function_families: &[], + relation_outputs: &[], relations: &relations, field_values: &field_values, point_values: &point_values, @@ -1437,21 +1445,21 @@ mod tests { } #[test] - fn output_claim_verification_rejects_conflicting_point_sources() -> Result<(), EmitError> { + fn relation_output_verification_rejects_conflicting_point_sources() -> Result<(), EmitError> { let field_values = VerifierScalarSourceSet::default(); let mut point_values = VerifierPointSourceSet::default(); point_values.insert("point", VerifierPointSourceKind::OpeningInput); point_values.insert("point", VerifierPointSourceKind::PointSlice); let relations = BTreeSet::new(); - let error = match verify_output_claims( + let error = match verify_relation_outputs( "stage", - OutputClaimVerification { - output_values: &[], - output_families: &[], - output_product_families: &[], - output_function_families: &[], - output_claims: &[], + RelationOutputVerification { + relation_output_values: &[], + relation_output_eval_families: &[], + relation_output_product_families: &[], + relation_output_function_families: &[], + relation_outputs: &[], relations: &relations, field_values: &field_values, point_values: &point_values, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 2e59e34293..4628d08a3b 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1415,10 +1415,10 @@ fn stage5_rust_targets_extract_and_compile() { prover_program.evals.len(), params.lookup_table_count + params.instruction_ra_virtual_d + 4 ); - assert_eq!(prover_program.output_values.len(), 4); - assert!(prover_program.output_claims.is_empty()); - assert_eq!(verifier_program.output_values.len(), 4); - assert_eq!(verifier_program.output_claims.len(), 3); + assert_eq!(prover_program.relation_output_values.len(), 4); + assert!(prover_program.relation_outputs.is_empty()); + assert_eq!(verifier_program.relation_output_values.len(), 4); + assert_eq!(verifier_program.relation_outputs.len(), 3); assert_eq!( prover_program.point_slices.len(), params.instruction_ra_virtual_d + 3 @@ -1480,9 +1480,7 @@ fn stage5_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("expected_registers_val_evaluation")); - assert!(verifier_source - .source - .contains("Stage5SumcheckOutputClaimPlan")); + assert!(verifier_source.source.contains("Stage5RelationOutputPlan")); assert!(verifier_source .source .contains("stage5.instruction_read_raf.output.claim_expr")); @@ -1494,7 +1492,7 @@ fn stage5_rust_targets_extract_and_compile() { .contains("stage5.registers_val_evaluation.output.lt.RegistersValCycle")); assert!(verifier_source .source - .contains("bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim")); + .contains("bolt_verifier_runtime::evaluate_relation_output_for_instance")); assert!(verifier_source .source .contains("Stage5RelationKind::Stage5RamRaClaimReduction")); @@ -1555,16 +1553,16 @@ fn stage6_rust_targets_extract_and_compile() { + params.instruction_d + 2 ); - assert_eq!(prover_program.output_values.len(), 8); - assert!(prover_program.output_claims.is_empty()); - assert_eq!(verifier_program.output_values.len(), 8); - assert_eq!(verifier_program.output_families.len(), 1); - assert_eq!(verifier_program.output_product_families.len(), 2); - assert_eq!(verifier_program.output_function_families.len(), 2); - assert_eq!(verifier_program.output_claims.len(), 6); + assert_eq!(prover_program.relation_output_values.len(), 8); + assert!(prover_program.relation_outputs.is_empty()); + assert_eq!(verifier_program.relation_output_values.len(), 8); + assert_eq!(verifier_program.relation_output_eval_families.len(), 1); + assert_eq!(verifier_program.relation_output_product_families.len(), 2); + assert_eq!(verifier_program.relation_output_function_families.len(), 2); + assert_eq!(verifier_program.relation_outputs.len(), 6); let total_booleanity_ra = params.instruction_d + params.bytecode_d + params.ram_d; let booleanity_function_families = verifier_program - .output_function_families + .relation_output_function_families .iter() .filter(|family| family.symbol == "stage6.booleanity.output.family") .collect::>(); @@ -1599,7 +1597,7 @@ fn stage6_rust_targets_extract_and_compile() { vec!["stage6.booleanity.output.eq.InstructionRa0".to_owned()] ); let hamming_function_families = verifier_program - .output_function_families + .relation_output_function_families .iter() .filter(|family| family.symbol == "stage6.hamming_booleanity.output.family") .collect::>(); @@ -1618,7 +1616,7 @@ fn stage6_rust_targets_extract_and_compile() { vec!["stage6.hamming_booleanity.output.eq.LookupOutput".to_owned()] ); let ram_product_families = verifier_program - .output_product_families + .relation_output_product_families .iter() .filter(|family| family.symbol == "stage6.ram_ra_virtual.output.family") .collect::>(); @@ -1638,7 +1636,7 @@ fn stage6_rust_targets_extract_and_compile() { vec!["stage6.ram_ra_virtual.output.eq.Cycle".to_owned()] ); let instruction_product_families = verifier_program - .output_product_families + .relation_output_product_families .iter() .filter(|family| family.symbol == "stage6.instruction_ra_virtual.output.family") .collect::>(); @@ -1669,7 +1667,7 @@ fn stage6_rust_targets_extract_and_compile() { vec!["stage6.instruction_ra_virtual.output.eq.Cycle".to_owned()] ); } - let inc_family = &verifier_program.output_families[0]; + let inc_family = &verifier_program.relation_output_eval_families[0]; assert_eq!( inc_family.symbol, "stage6.inc_claim_reduction.output.family" @@ -1703,7 +1701,7 @@ fn stage6_rust_targets_extract_and_compile() { ] ); let inc_claims = verifier_program - .output_claims + .relation_outputs .iter() .filter(|claim| claim.expected_output == "stage6.inc_claim_reduction.output.family") .collect::>(); @@ -1712,7 +1710,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(inc_claims[0].product_families.is_empty()); assert!(inc_claims[0].function_families.is_empty()); let booleanity_claims = verifier_program - .output_claims + .relation_outputs .iter() .filter(|claim| claim.expected_output == "stage6.booleanity.output.family") .collect::>(); @@ -1728,7 +1726,7 @@ fn stage6_rust_targets_extract_and_compile() { "stage6.booleanity.output.eq.InstructionRa0" ); let hamming_claims = verifier_program - .output_claims + .relation_outputs .iter() .filter(|claim| claim.expected_output == "stage6.hamming_booleanity.output.family") .collect::>(); @@ -1740,7 +1738,7 @@ fn stage6_rust_targets_extract_and_compile() { vec![hamming_function_family.clone()] ); let ram_ra_claims = verifier_program - .output_claims + .relation_outputs .iter() .filter(|claim| claim.expected_output == "stage6.ram_ra_virtual.output.family") .collect::>(); @@ -1752,7 +1750,7 @@ fn stage6_rust_targets_extract_and_compile() { ); assert!(ram_ra_claims[0].function_families.is_empty()); let instruction_ra_claims = verifier_program - .output_claims + .relation_outputs .iter() .filter(|claim| claim.expected_output == "stage6.instruction_ra_virtual.output.family") .collect::>(); @@ -1764,7 +1762,7 @@ fn stage6_rust_targets_extract_and_compile() { ); assert!(instruction_ra_claims[0].function_families.is_empty()); let bytecode_claims = verifier_program - .output_claims + .relation_outputs .iter() .filter(|claim| { claim.expected_output == "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" @@ -1886,7 +1884,7 @@ fn stage6_rust_targets_extract_and_compile() { .contains("expected_hamming_booleanity")); assert!(verifier_source .source - .contains("expected_plan_output_claim")); + .contains("expected_plan_relation_output")); assert!(verifier_source .source .contains("stage6.booleanity.output.eq.InstructionRa0")); @@ -1909,27 +1907,25 @@ fn stage6_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("expected_inc_claim_reduction")); + assert!(verifier_source.source.contains("Stage6RelationOutputPlan")); assert!(verifier_source .source - .contains("Stage6SumcheckOutputClaimPlan")); - assert!(verifier_source - .source - .contains("SumcheckOutputFunctionFamilyPlan")); + .contains("RelationOutputFunctionFamilyPlan")); assert!(verifier_source .source - .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES")); + .contains("STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES")); assert!(verifier_source .source - .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES")); + .contains("STAGE6_RELATION_OUTPUT_4_FAMILIES")); assert!(verifier_source .source - .contains("SumcheckOutputProductFamilyPlan")); + .contains("RelationOutputProductFamilyPlan")); assert!(verifier_source .source - .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES")); + .contains("STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES")); assert!(verifier_source .source - .contains("STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES")); + .contains("STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES")); assert!(verifier_source .source .contains("stage6.booleanity.output.family")); @@ -2038,12 +2034,12 @@ fn stage7_rust_targets_extract_and_compile() { assert_eq!(prover_program.drivers.len(), 1); assert_eq!(prover_program.instance_results.len(), 1); assert_eq!(prover_program.evals.len(), total_ra); - assert_eq!(prover_program.output_values.len(), total_ra + 1); - assert!(prover_program.output_claims.is_empty()); - assert_eq!(verifier_program.output_values.len(), total_ra + 1); - assert_eq!(verifier_program.output_families.len(), 1); - assert_eq!(verifier_program.output_claims.len(), 1); - let output_family = &verifier_program.output_families[0]; + assert_eq!(prover_program.relation_output_values.len(), total_ra + 1); + assert!(prover_program.relation_outputs.is_empty()); + assert_eq!(verifier_program.relation_output_values.len(), total_ra + 1); + assert_eq!(verifier_program.relation_output_eval_families.len(), 1); + assert_eq!(verifier_program.relation_outputs.len(), 1); + let output_family = &verifier_program.relation_output_eval_families[0]; assert_eq!( output_family.symbol, "stage7.hamming_weight_claim_reduction.output.family" @@ -2065,7 +2061,7 @@ fn stage7_rust_targets_extract_and_compile() { assert_eq!(output_family.item_terms[0].gamma_power_offset, 2); assert_eq!(output_family.item_terms[0].factors.len(), total_ra); assert_eq!( - verifier_program.output_claims[0].eval_families, + verifier_program.relation_outputs[0].eval_families, vec![output_family.clone()] ); assert!(prover_program.point_zeros.is_empty()); @@ -2116,15 +2112,13 @@ fn stage7_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("expected_hamming_weight_claim_reduction")); + assert!(verifier_source.source.contains("Stage7RelationOutputPlan")); assert!(verifier_source .source - .contains("Stage7SumcheckOutputClaimPlan")); - assert!(verifier_source - .source - .contains("SumcheckOutputEvalFamilyPlan")); + .contains("RelationOutputEvalFamilyPlan")); assert!(verifier_source .source - .contains("STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_EVALS")); + .contains("STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS")); assert!(verifier_source .source .contains("stage7.hamming_weight_claim_reduction.output.eq.Booleanity")); @@ -2136,7 +2130,7 @@ fn stage7_rust_targets_extract_and_compile() { .contains("stage7.hamming_weight_claim_reduction.output.term")); assert!(verifier_source .source - .contains("bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim")); + .contains("bolt_verifier_runtime::evaluate_relation_output_for_instance")); assert!(verifier_source .source .contains("stage7.input.stage6.booleanity.InstructionRa_0")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index d7138b09a8..a7493af1c8 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -389,11 +389,11 @@ fn generated_sumcheck_point_order(value: &str) -> bolt_verifier_runtime::Sumchec clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" )] -fn generated_output_function_kind( +fn generated_relation_output_function_kind( value: &str, -) -> bolt_verifier_runtime::SumcheckOutputFunctionKind { +) -> bolt_verifier_runtime::RelationOutputFunctionKind { match value { - "boolean_zero" => bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, + "boolean_zero" => bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, value => panic!("unsupported generated output function `{value}`"), } } @@ -469,8 +469,8 @@ macro_rules! define_stage_adapter_impl { $(, transcript_absorb_bytes = $absorb:ident)? $(, kernels = $kernel:ident)? $(, point_zeros = $point_zero:ident)? - $(, output_claims = $output_claim:ident, output_values = $output_value:ident)? - $(, empty_output_claims = $empty_output_claims:ident)? + $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? ) => { pub fn $function(program: &$compiler) -> &'static $module::$program { @@ -619,16 +619,16 @@ macro_rules! define_stage_adapter_impl { .collect(), ), $( - output_claims: super::leak_slice( + relation_outputs: super::leak_slice( program - .output_claims + .relation_outputs .iter() - .map(|plan| $module::$output_claim { + .map(|plan| $module::$relation_output { relation: super::generated_relation_kind(&plan.relation), polynomial_evals: super::leak_slice( plan.polynomial_evals .iter() - .map(|value| $module::$output_value { + .map(|value| $module::$relation_output_value { symbol: super::leak_str(&value.symbol), polynomial: super::generated_structured_polynomial_kind(value.polynomial.as_str()), x_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { @@ -649,7 +649,7 @@ macro_rules! define_stage_adapter_impl { eval_families: super::leak_slice( plan.eval_families .iter() - .map(|family| bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { + .map(|family| bolt_verifier_runtime::RelationOutputEvalFamilyPlan { symbol: super::leak_str(&family.symbol), gamma: super::leak_str(&family.gamma), evals: super::leak_slice( @@ -667,7 +667,7 @@ macro_rules! define_stage_adapter_impl { family .shared_terms .iter() - .map(|term| bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan { + .map(|term| bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan { gamma_power_offset: term.gamma_power_offset, factor: super::leak_str(&term.factor), }) @@ -677,7 +677,7 @@ macro_rules! define_stage_adapter_impl { family .item_terms .iter() - .map(|term| bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { + .map(|term| bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan { gamma_power_offset: term.gamma_power_offset, factors: super::leak_slice( term @@ -695,14 +695,14 @@ macro_rules! define_stage_adapter_impl { product_families: super::leak_slice( plan.product_families .iter() - .map(|family| bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { + .map(|family| bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: super::leak_str(&family.symbol), gamma: family.gamma.as_ref().map(|gamma| super::leak_str(gamma)), terms: super::leak_slice( family .terms .iter() - .map(|term| bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { + .map(|term| bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: term.gamma_power_offset, evals: super::leak_slice( term @@ -734,16 +734,16 @@ macro_rules! define_stage_adapter_impl { function_families: super::leak_slice( plan.function_families .iter() - .map(|family| bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { + .map(|family| bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { symbol: super::leak_str(&family.symbol), gamma: family.gamma.as_ref().map(|gamma| super::leak_str(gamma)), terms: super::leak_slice( family .terms .iter() - .map(|term| bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { + .map(|term| bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: term.gamma_power_offset, - function: super::generated_output_function_kind(term.function.as_str()), + function: super::generated_relation_output_function_kind(term.function.as_str()), eval: super::leak_str(&term.eval), factors: super::leak_slice( term @@ -765,8 +765,8 @@ macro_rules! define_stage_adapter_impl { ), )? $( - output_claims: { - let _ = stringify!($empty_output_claims); + relation_outputs: { + let _ = stringify!($empty_relation_outputs); &[] }, )? @@ -883,8 +883,8 @@ macro_rules! define_stage_adapter { $opening_equality:ident, $opening_batch:ident $(, point_zero = $point_zero:ident)? - $(, output_claims = $output_claim:ident, output_values = $output_value:ident)? - $(, empty_output_claims = $empty_output_claims:ident)? + $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, empty_relation_outputs = $empty_relation_outputs:ident)? ) => { define_stage_adapter_impl!( $mode, @@ -911,8 +911,8 @@ macro_rules! define_stage_adapter { transcript_absorb_bytes = $absorb, kernels = $kernel $(, point_zeros = $point_zero)? - $(, output_claims = $output_claim, output_values = $output_value)? - $(, empty_output_claims = $empty_output_claims)? + $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, empty_relation_outputs = $empty_relation_outputs)? , opening_equalities = $opening_equality ); @@ -942,8 +942,8 @@ macro_rules! define_stage_adapter_no_absorb { $opening_claim:ident, $opening_batch:ident $(, kernels = $kernel:ident)? - $(, output_claims = $output_claim:ident, output_values = $output_value:ident)? - $(, empty_output_claims = $empty_output_claims:ident)? + $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? ) => { define_stage_adapter_impl!( @@ -968,8 +968,8 @@ macro_rules! define_stage_adapter_no_absorb { $opening_claim, $opening_batch $(, kernels = $kernel)? - $(, output_claims = $output_claim, output_values = $output_value)? - $(, empty_output_claims = $empty_output_claims)? + $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, empty_relation_outputs = $empty_relation_outputs)? $(, opening_equalities = $opening_equality)? ); }; diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs index 2964ce15c1..223ff3f2da 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs @@ -22,7 +22,7 @@ define_stage_adapter_no_absorb!( Stage3PointConcatPlan, Stage3OpeningClaimPlan, Stage3OpeningBatchPlan, - output_claims = Stage3SumcheckOutputClaimPlan, - output_values = Stage3StructuredPolynomialEvalPlan, + relation_outputs = Stage3RelationOutputPlan, + relation_output_values = Stage3StructuredPolynomialEvalPlan, opening_equalities = Stage3OpeningClaimEqualityPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs index 05273e588a..08e83ed2de 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs @@ -25,6 +25,6 @@ define_stage_adapter!( Stage4OpeningClaimPlan, Stage4OpeningClaimEqualityPlan, Stage4OpeningBatchPlan, - output_claims = Stage4SumcheckOutputClaimPlan, - output_values = Stage4StructuredPolynomialEvalPlan + relation_outputs = Stage4RelationOutputPlan, + relation_output_values = Stage4StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs index cbed81baca..83b8661dad 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs @@ -25,6 +25,6 @@ define_stage_adapter!( Stage5OpeningClaimPlan, Stage5OpeningClaimEqualityPlan, Stage5OpeningBatchPlan, - output_claims = Stage5SumcheckOutputClaimPlan, - output_values = Stage5StructuredPolynomialEvalPlan + relation_outputs = Stage5RelationOutputPlan, + relation_output_values = Stage5StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs index 471e9481af..533fc349e0 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs @@ -26,6 +26,6 @@ define_stage_adapter!( Stage6OpeningClaimEqualityPlan, Stage6OpeningBatchPlan, point_zero = Stage6PointZeroPlan, - output_claims = Stage6SumcheckOutputClaimPlan, - output_values = Stage6StructuredPolynomialEvalPlan + relation_outputs = Stage6RelationOutputPlan, + relation_output_values = Stage6StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs index d88ea66e7a..ce4395238a 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs @@ -26,6 +26,6 @@ define_stage_adapter!( Stage7OpeningClaimEqualityPlan, Stage7OpeningBatchPlan, point_zero = Stage7PointZeroPlan, - output_claims = Stage7SumcheckOutputClaimPlan, - output_values = Stage7StructuredPolynomialEvalPlan + relation_outputs = Stage7RelationOutputPlan, + relation_output_values = Stage7StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index e41643a26a..e7b5220138 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -17,7 +17,7 @@ pub type Stage3VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgram pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage3SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub type Stage3SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage3RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub type Stage3StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind; @@ -210,23 +210,23 @@ pub const STAGE3_OPENING_EQUALITIES: &[Stage3OpeningClaimEqualityPlan] = &[ pub const STAGE3_OPENING_BATCHES: &[Stage3OpeningBatchPlan] = &[ Stage3OpeningBatchPlan { symbol: "stage3.openings", stage: "stage3", proof_slot: "stage3.openings", policy: "jolt_stage3_output_order", count: 16, ordered_claims: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"], claim_operands: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"] }, ]; -pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ +pub const STAGE3_RELATION_OUTPUT_0_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ Stage3StructuredPolynomialEvalPlan { symbol: "stage3.spartan_shift.output.eq.NextPC", polynomial: Stage3StructuredPolynomialKind::EqPlusOne, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage1.NextPC", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, Stage3StructuredPolynomialEvalPlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", polynomial: Stage3StructuredPolynomialKind::EqPlusOne, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage2.product_virtual.NextIsNoop", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ +pub const STAGE3_RELATION_OUTPUT_1_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ Stage3StructuredPolynomialEvalPlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", polynomial: Stage3StructuredPolynomialKind::Eq, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.instruction_input.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage2.product_virtual.LeftInstructionInput", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ +pub const STAGE3_RELATION_OUTPUT_2_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ Stage3StructuredPolynomialEvalPlan { symbol: "stage3.registers.output.eq.RdWriteValue", polynomial: Stage3StructuredPolynomialKind::Eq, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.registers_claim_reduction.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage1.RdWriteValue", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE3_SUMCHECK_OUTPUT_CLAIMS: &[Stage3SumcheckOutputClaimPlan] = &[ - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, - Stage3SumcheckOutputClaimPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, +pub const STAGE3_RELATION_OUTPUTS: &[Stage3RelationOutputPlan] = &[ + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_RELATION_OUTPUT_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_RELATION_OUTPUT_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_RELATION_OUTPUT_2_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { @@ -241,7 +241,7 @@ pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan drivers: STAGE3_SUMCHECK_DRIVERS, instance_results: STAGE3_SUMCHECK_INSTANCE_RESULTS, evals: STAGE3_SUMCHECK_EVALS, - output_claims: STAGE3_SUMCHECK_OUTPUT_CLAIMS, + relation_outputs: STAGE3_RELATION_OUTPUTS, point_slices: STAGE3_POINT_SLICES, point_concats: STAGE3_POINT_CONCATS, opening_claims: STAGE3_OPENING_CLAIMS, @@ -487,8 +487,8 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let value = bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 0f702236b7..85f3447aff 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -15,7 +15,7 @@ pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZe pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage4SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub type Stage4SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage4RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub type Stage4StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind; @@ -174,17 +174,17 @@ pub const STAGE4_OPENING_EQUALITIES: &[Stage4OpeningClaimEqualityPlan] = &[ pub const STAGE4_OPENING_BATCHES: &[Stage4OpeningBatchPlan] = &[ Stage4OpeningBatchPlan { symbol: "stage4.openings", stage: "stage4", proof_slot: "stage4.openings", policy: "jolt_stage4_output_order", count: 7, ordered_claims: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"], claim_operands: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"] }, ]; -pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage4StructuredPolynomialEvalPlan] = &[ +pub const STAGE4_RELATION_OUTPUT_0_VALUES: &[Stage4StructuredPolynomialEvalPlan] = &[ Stage4StructuredPolynomialEvalPlan { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", polynomial: Stage4StructuredPolynomialKind::Eq, x_point: Stage4StructuredPolynomialPointPlan { source: "stage4.registers_read_write.instance", segment: Stage4StructuredPolynomialPointSegment::Prefix, length: Stage4StructuredPolynomialPointLength::YPoint, order: Stage4StructuredPolynomialPointOrder::Reverse }, y_point: Stage4StructuredPolynomialPointPlan { source: "stage4.input.stage3.registers.RdWriteValue", segment: Stage4StructuredPolynomialPointSegment::Full, length: Stage4StructuredPolynomialPointLength::Full, order: Stage4StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage4StructuredPolynomialEvalPlan] = &[ +pub const STAGE4_RELATION_OUTPUT_1_VALUES: &[Stage4StructuredPolynomialEvalPlan] = &[ Stage4StructuredPolynomialEvalPlan { symbol: "stage4.ram_val_check.output.lt.RamValCycle", polynomial: Stage4StructuredPolynomialKind::Lt, x_point: Stage4StructuredPolynomialPointPlan { source: "stage4.ram_val_check.instance", segment: Stage4StructuredPolynomialPointSegment::Full, length: Stage4StructuredPolynomialPointLength::Full, order: Stage4StructuredPolynomialPointOrder::Reverse }, y_point: Stage4StructuredPolynomialPointPlan { source: "stage4.input.stage2.RamVal", segment: Stage4StructuredPolynomialPointSegment::Suffix, length: Stage4StructuredPolynomialPointLength::XPoint, order: Stage4StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE4_SUMCHECK_OUTPUT_CLAIMS: &[Stage4SumcheckOutputClaimPlan] = &[ - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, - Stage4SumcheckOutputClaimPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, +pub const STAGE4_RELATION_OUTPUTS: &[Stage4RelationOutputPlan] = &[ + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_RELATION_OUTPUT_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_RELATION_OUTPUT_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { @@ -202,7 +202,7 @@ pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { drivers: STAGE4_SUMCHECK_DRIVERS, instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS, evals: STAGE4_SUMCHECK_EVALS, - output_claims: STAGE4_SUMCHECK_OUTPUT_CLAIMS, + relation_outputs: STAGE4_RELATION_OUTPUTS, point_slices: STAGE4_POINT_SLICES, point_concats: STAGE4_POINT_CONCATS, opening_claims: STAGE4_OPENING_CLAIMS, @@ -464,8 +464,8 @@ fn expected_batched_output_claim( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let value = bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 34659bbd9f..1a0ff1ebc7 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -16,7 +16,7 @@ pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZe pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage5SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub type Stage5SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage5RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub type Stage5StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage5RelationKind; @@ -359,76 +359,76 @@ pub const STAGE5_INDEXED_EVAL_FAMILIES: &[bolt_verifier_runtime::NamedEvalFamily bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.InstructionRa", evals: STAGE5_INDEXED_EVAL_FAMILY_1_NAMES }, ]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ +pub const STAGE5_RELATION_OUTPUT_0_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.ram_raf.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.ram_read_write.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage4.ram_val_check.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ +pub const STAGE5_RELATION_OUTPUT_1_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ Stage5StructuredPolynomialEvalPlan { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", polynomial: Stage5StructuredPolynomialKind::Lt, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.registers_val_evaluation.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage4.registers.RegistersVal", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ +pub const STAGE5_RELATION_OUTPUT_2_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ Stage5StructuredPolynomialEvalPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.instruction_read_raf.point", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::YPoint, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.instruction.LookupOutput", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"], eval_families: &[], factors: &[] }, +pub const STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"], eval_families: &[], factors: &[] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"], eval_families: &[], factors: &[] }, ]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &[], eval_families: &["stage5.instruction_read_raf.eval.InstructionRa"], factors: &[] }, +pub const STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILY_1_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &[], eval_families: &["stage5.instruction_read_raf.eval.InstructionRa"], factors: &[] }, ]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.LookupTableValues", gamma: None, terms: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, - bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", gamma: None, terms: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_1_TERMS }, +pub const STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::RelationOutputProductFamilyPlan] = &[ + bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.LookupTableValues", gamma: None, terms: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS }, + bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", gamma: None, terms: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILY_1_TERMS }, ]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIM_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; -pub const STAGE5_SUMCHECK_OUTPUT_CLAIMS: &[Stage5SumcheckOutputClaimPlan] = &[ - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, - Stage5SumcheckOutputClaimPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, polynomial_evals: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE5_SUMCHECK_OUTPUT_CLAIM_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, +pub const STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; +pub const STAGE5_RELATION_OUTPUTS: &[Stage5RelationOutputPlan] = &[ + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_RELATION_OUTPUT_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_RELATION_OUTPUT_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, polynomial_evals: STAGE5_RELATION_OUTPUT_2_VALUES, eval_families: &[], product_families: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { @@ -446,7 +446,7 @@ pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { drivers: STAGE5_SUMCHECK_DRIVERS, instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS, evals: STAGE5_SUMCHECK_EVALS, - output_claims: STAGE5_SUMCHECK_OUTPUT_CLAIMS, + relation_outputs: STAGE5_RELATION_OUTPUTS, point_slices: STAGE5_POINT_SLICES, point_concats: STAGE5_POINT_CONCATS, opening_claims: STAGE5_OPENING_CLAIMS, @@ -721,8 +721,8 @@ fn expected_batched_output_claim( &STAGE5_INSTRUCTION_READ_RAF_PLAN, local_point, )?; - bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, @@ -734,8 +734,8 @@ fn expected_batched_output_claim( } Stage5RelationKind::Stage5RamRaClaimReduction | Stage5RelationKind::Stage5RegistersValEvaluation => { - bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 8d43531242..cd7449805b 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -16,7 +16,7 @@ pub type Stage6CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage6SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage6SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub type Stage6SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage6RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub type Stage6StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage6RelationKind; @@ -633,133 +633,133 @@ const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafP }, entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ +pub const STAGE6_RELATION_OUTPUT_0_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.booleanity.output.eq.InstructionRa0", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.output.point", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 2, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 4, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 6, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_3", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 8, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_4", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 10, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_5", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 12, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_6", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 14, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_7", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 16, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_8", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 18, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_9", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 20, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_10", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 22, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_11", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 24, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_12", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 26, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_13", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 28, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_14", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 30, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_15", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 32, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_16", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 34, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_17", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 36, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_18", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 38, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_19", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 40, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_20", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 42, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_21", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 44, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_22", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 46, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_23", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 48, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_24", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 50, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_25", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 52, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_26", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 54, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_27", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 56, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_28", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 58, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_29", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 60, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_30", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 62, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_31", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 64, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 66, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 68, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 70, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 72, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 74, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 76, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_3", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, +pub const STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan] = &[ + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 2, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 4, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 6, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_3", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 8, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_4", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 10, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_5", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 12, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_6", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 14, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_7", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 16, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_8", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 18, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_9", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 20, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_10", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 22, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_11", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 24, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_12", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 26, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_13", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 28, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_14", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 30, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_15", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 32, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_16", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 34, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_17", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 36, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_18", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 38, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_19", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 40, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_20", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 42, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_21", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 44, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_22", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 46, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_23", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 48, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_24", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 50, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_25", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 52, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_26", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 54, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_27", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 56, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_28", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 58, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_29", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 60, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_30", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 62, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_31", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 64, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 66, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 68, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 70, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 72, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 74, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 76, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_3", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: "stage6.booleanity.output.family", gamma: Some("stage6.booleanity.gamma"), terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILY_0_TERMS }, +pub const STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::RelationOutputFunctionFamilyPlan] = &[ + bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { symbol: "stage6.booleanity.output.family", gamma: Some("stage6.booleanity.gamma"), terms: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILY_0_TERMS }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ +pub const STAGE6_RELATION_OUTPUT_1_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.hamming_booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage1.LookupOutput", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::SumcheckOutputFunctionKind::BooleanZero, eval: "stage6.hamming_booleanity.eval.HammingWeight", factors: &["stage6.hamming_booleanity.output.eq.LookupOutput"] }, +pub const STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan] = &[ + bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.hamming_booleanity.eval.HammingWeight", factors: &["stage6.hamming_booleanity.output.eq.LookupOutput"] }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputFunctionFamilyPlan { symbol: "stage6.hamming_booleanity.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILY_0_TERMS }, +pub const STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILIES: &[bolt_verifier_runtime::RelationOutputFunctionFamilyPlan] = &[ + bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { symbol: "stage6.hamming_booleanity.output.family", gamma: None, terms: STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILY_0_TERMS }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ +pub const STAGE6_RELATION_OUTPUT_2_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.ram_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"], eval_families: &[], factors: &["stage6.ram_ra_virtual.output.eq.Cycle"] }, +pub const STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"], eval_families: &[], factors: &["stage6.ram_ra_virtual.output.eq.Cycle"] }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILY_0_TERMS }, +pub const STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::RelationOutputProductFamilyPlan] = &[ + bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: None, terms: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ +pub const STAGE6_RELATION_OUTPUT_3_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.instruction_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 3, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 4, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 5, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 6, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, +pub const STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 3, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 4, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 5, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 6, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: Some("stage6.instruction_ra_virtual.gamma"), terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILY_0_TERMS }, +pub const STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES: &[bolt_verifier_runtime::RelationOutputProductFamilyPlan] = &[ + bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: Some("stage6.instruction_ra_virtual.gamma"), terms: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILY_0_TERMS }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ +pub const STAGE6_RELATION_OUTPUT_4_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage2.ram_read_write.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.ram_val_check.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.registers_read_write.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.registers_val_evaluation.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_EVALS: &[&str] = &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.eval.RdInc"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan] = &[ +pub const STAGE6_RELATION_OUTPUT_4_FAMILY_0_EVALS: &[&str] = &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.eval.RdInc"]; +pub const STAGE6_RELATION_OUTPUT_4_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan] = &[ ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 0, factors: &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"] }, - bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 1, factors: &["stage6.inc_claim_reduction.output.eq.RamIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage5"] }, +pub const STAGE6_RELATION_OUTPUT_4_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan] = &[ + bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan { gamma_power_offset: 0, factors: &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"] }, + bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan { gamma_power_offset: 1, factors: &["stage6.inc_claim_reduction.output.eq.RamIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage5"] }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage6.inc_claim_reduction.output.family", gamma: "stage6.inc_claim_reduction.gamma", evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_EVALS, power_stride: 2, value_term_offsets: &[], shared_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_SHARED_TERMS, item_terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILY_0_ITEM_TERMS }, +pub const STAGE6_RELATION_OUTPUT_4_FAMILIES: &[bolt_verifier_runtime::RelationOutputEvalFamilyPlan] = &[ + bolt_verifier_runtime::RelationOutputEvalFamilyPlan { symbol: "stage6.inc_claim_reduction.output.family", gamma: "stage6.inc_claim_reduction.gamma", evals: STAGE6_RELATION_OUTPUT_4_FAMILY_0_EVALS, power_stride: 2, value_term_offsets: &[], shared_terms: STAGE6_RELATION_OUTPUT_4_FAMILY_0_SHARED_TERMS, item_terms: STAGE6_RELATION_OUTPUT_4_FAMILY_0_ITEM_TERMS }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ +pub const STAGE6_RELATION_OUTPUT_5_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.bytecode_read_raf.output.contribution"], eval_families: &["stage6.bytecode_read_raf.eval.BytecodeRa"], factors: &[] }, +pub const STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ + bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.bytecode_read_raf.output.contribution"], eval_families: &["stage6.bytecode_read_raf.eval.BytecodeRa"], factors: &[] }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputProductFamilyPlan { symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf", gamma: None, terms: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILY_0_TERMS }, +pub const STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES: &[bolt_verifier_runtime::RelationOutputProductFamilyPlan] = &[ + bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf", gamma: None, terms: STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILY_0_TERMS }, ]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIM_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; -pub const STAGE6_SUMCHECK_OUTPUT_CLAIMS: &[Stage6SumcheckOutputClaimPlan] = &[ - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6Booleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_1_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_VALUES, eval_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.family" }, - Stage6SumcheckOutputClaimPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, polynomial_evals: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_VALUES, eval_families: &[], product_families: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_SUMCHECK_OUTPUT_CLAIM_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, +pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; +pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, polynomial_evals: STAGE6_RELATION_OUTPUT_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_RELATION_OUTPUT_1_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_RELATION_OUTPUT_2_VALUES, eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_RELATION_OUTPUT_3_VALUES, eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_RELATION_OUTPUT_4_VALUES, eval_families: STAGE6_RELATION_OUTPUT_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, polynomial_evals: STAGE6_RELATION_OUTPUT_5_VALUES, eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { @@ -777,7 +777,7 @@ pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { drivers: STAGE6_SUMCHECK_DRIVERS, instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS, evals: STAGE6_SUMCHECK_EVALS, - output_claims: STAGE6_SUMCHECK_OUTPUT_CLAIMS, + relation_outputs: STAGE6_RELATION_OUTPUTS, point_zeros: STAGE6_POINT_ZEROS, point_slices: STAGE6_POINT_SLICES, point_concats: STAGE6_POINT_CONCATS, @@ -1089,13 +1089,13 @@ fn expected_batched_output_claim( local_point, log_t, )?; - expected_plan_output_claim(program, instance, store, evals, &local_scalars, local_point)? + expected_plan_relation_output(program, instance, store, evals, &local_scalars, local_point)? } Stage6RelationKind::Stage6Booleanity | Stage6RelationKind::Stage6HammingBooleanity | Stage6RelationKind::Stage6RamRaVirtual | Stage6RelationKind::Stage6InstructionRaVirtual - | Stage6RelationKind::Stage6IncClaimReduction => expected_plan_output_claim( + | Stage6RelationKind::Stage6IncClaimReduction => expected_plan_relation_output( program, instance, store, @@ -1110,7 +1110,7 @@ fn expected_batched_output_claim( Ok(expected) } -fn expected_plan_output_claim( +fn expected_plan_relation_output( program: &'static Stage6VerifierProgramPlan, instance: &'static Stage6SumcheckInstanceResultPlan, store: &bolt_verifier_runtime::ValueStore, @@ -1118,8 +1118,8 @@ fn expected_plan_output_claim( local_scalars: &[bolt_verifier_runtime::NamedScalar], local_point: &[Fr], ) -> Result { - Ok(bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + Ok(bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 4ad4b7151f..a8314584c6 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -15,7 +15,7 @@ pub type Stage7CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage7SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage7SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; -pub type Stage7SumcheckOutputClaimPlan = bolt_verifier_runtime::SumcheckOutputClaimPlan; +pub type Stage7RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub type Stage7StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage7RelationKind; @@ -229,7 +229,7 @@ pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_DRIVERS: &[Stage7SumcheckDriverPlan] = &[ Stage7SumcheckDriverPlan { symbol: "stage7.sumcheck", stage: "stage7", proof_slot: "stage7.sumcheck", kernel: None, relation: Some(Stage7RelationKind::Stage7Batched), batch: "stage7.batch", policy: "jolt_core_stage7_aligned", round_schedule: STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 4, degree: 2 }, ]; -pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage7StructuredPolynomialEvalPlan] = &[ +pub const STAGE7_RELATION_OUTPUT_0_VALUES: &[Stage7StructuredPolynomialEvalPlan] = &[ Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.booleanity.InstructionRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, @@ -272,20 +272,20 @@ pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES: &[Stage7StructuredPolynomialEva Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_3", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_EVALS: &[&str] = &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3"]; -pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputEvalFamilySharedTermPlan { gamma_power_offset: 1, factor: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity" }, +pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS: &[&str] = &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3"]; +pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan] = &[ + bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan { gamma_power_offset: 1, factor: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity" }, ]; -pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERM_0_FACTORS: &[&str] = &["stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]; -pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan] = &[ - bolt_verifier_runtime::SumcheckOutputEvalFamilyItemTermPlan { gamma_power_offset: 2, factors: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERM_0_FACTORS }, +pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_ITEM_TERM_0_FACTORS: &[&str] = &["stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]; +pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan] = &[ + bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan { gamma_power_offset: 2, factors: STAGE7_RELATION_OUTPUT_0_FAMILY_0_ITEM_TERM_0_FACTORS }, ]; -pub const STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES: &[bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan] = &[ - bolt_verifier_runtime::SumcheckOutputEvalFamilyPlan { symbol: "stage7.hamming_weight_claim_reduction.output.family", gamma: "stage7.hamming_weight_claim_reduction.gamma", evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_EVALS, power_stride: 3, value_term_offsets: &[0], shared_terms: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_SHARED_TERMS, item_terms: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILY_0_ITEM_TERMS }, +pub const STAGE7_RELATION_OUTPUT_0_FAMILIES: &[bolt_verifier_runtime::RelationOutputEvalFamilyPlan] = &[ + bolt_verifier_runtime::RelationOutputEvalFamilyPlan { symbol: "stage7.hamming_weight_claim_reduction.output.family", gamma: "stage7.hamming_weight_claim_reduction.gamma", evals: STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS, power_stride: 3, value_term_offsets: &[0], shared_terms: STAGE7_RELATION_OUTPUT_0_FAMILY_0_SHARED_TERMS, item_terms: STAGE7_RELATION_OUTPUT_0_FAMILY_0_ITEM_TERMS }, ]; -pub const STAGE7_SUMCHECK_OUTPUT_CLAIMS: &[Stage7SumcheckOutputClaimPlan] = &[ - Stage7SumcheckOutputClaimPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_VALUES, eval_families: STAGE7_SUMCHECK_OUTPUT_CLAIM_0_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.family" }, +pub const STAGE7_RELATION_OUTPUTS: &[Stage7RelationOutputPlan] = &[ + Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_RELATION_OUTPUT_0_VALUES, eval_families: STAGE7_RELATION_OUTPUT_0_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.family" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ @@ -385,7 +385,7 @@ pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan { drivers: STAGE7_SUMCHECK_DRIVERS, instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS, evals: STAGE7_SUMCHECK_EVALS, - output_claims: STAGE7_SUMCHECK_OUTPUT_CLAIMS, + relation_outputs: STAGE7_RELATION_OUTPUTS, point_zeros: STAGE7_POINT_ZEROS, point_slices: STAGE7_POINT_SLICES, point_concats: STAGE7_POINT_CONCATS, @@ -661,8 +661,8 @@ fn expected_batched_output_claim( }; let value = match relation { Stage7RelationKind::Stage7HammingWeightClaimReduction => { - bolt_verifier_runtime::evaluate_sumcheck_instance_output_claim( - program.output_claims, + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, program.field_exprs, store, instance, From 2ea07c0d323d955e3a6c2159e549a2af9e0189c0 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 19:25:55 -0600 Subject: [PATCH 097/171] refactor(bolt): lift relation output values --- crates/bolt-verifier-runtime/src/lib.rs | 16 ++++- .../jolt/emit/rust/relation_outputs.rs | 61 ++++++++++++------- .../src/protocols/jolt/emit/rust/stage3.rs | 3 + .../src/protocols/jolt/emit/rust/stage4.rs | 4 +- .../src/protocols/jolt/emit/rust/stage5.rs | 8 ++- .../src/protocols/jolt/emit/rust/stage6.rs | 6 +- .../src/protocols/jolt/emit/rust/stage7.rs | 4 +- .../jolt/stage5_instruction_read_raf_plan.rs | 10 +-- .../jolt/stage6_bytecode_read_raf_plan.rs | 4 +- .../bolt/src/protocols/jolt/verifier_plan.rs | 2 +- .../jolt/verifier_relation_outputs.rs | 9 ++- crates/bolt/tests/commitment_ir.rs | 6 +- crates/jolt-equivalence/src/plan_adapters.rs | 48 ++++++++------- crates/jolt-verifier/src/stages/stage3.rs | 16 ++--- crates/jolt-verifier/src/stages/stage4.rs | 11 ++-- crates/jolt-verifier/src/stages/stage5.rs | 21 +++---- crates/jolt-verifier/src/stages/stage6.rs | 46 +++++--------- crates/jolt-verifier/src/stages/stage7.rs | 7 ++- 18 files changed, 155 insertions(+), 127 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 75eddf87de..7dc7919755 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -439,7 +439,7 @@ pub struct RelationOutputFunctionFamilyPlan { #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: R, - pub polynomial_evals: &'static [StructuredPolynomialEvalPlan], + pub structured_polynomial_evals: &'static [&'static str], pub eval_families: &'static [RelationOutputEvalFamilyPlan], pub product_families: &'static [RelationOutputProductFamilyPlan], pub function_families: &'static [RelationOutputFunctionFamilyPlan], @@ -531,6 +531,7 @@ pub struct StageProgramPlan { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], + pub relation_output_values: &'static [StructuredPolynomialEvalPlan], pub relation_outputs: &'static [RelationOutputPlan], pub point_zeros: &'static [PointZeroPlan], pub point_slices: &'static [PointSlicePlan], @@ -556,6 +557,7 @@ pub struct StageProgramPlanNoPointZeros { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], + pub relation_output_values: &'static [StructuredPolynomialEvalPlan], pub relation_outputs: &'static [RelationOutputPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], @@ -577,6 +579,7 @@ pub struct StageVerifierProgramPlan { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], + pub relation_output_values: &'static [StructuredPolynomialEvalPlan], pub relation_outputs: &'static [RelationOutputPlan], pub point_slices: &'static [PointSlicePlan], pub point_concats: &'static [PointConcatPlan], @@ -1299,6 +1302,7 @@ pub fn eval_family_values( pub fn evaluate_relation_output( plan: &RelationOutputPlan, + relation_output_values: &[StructuredPolynomialEvalPlan], field_exprs: &[FieldExprPlan], store: &ValueStore, instance_symbol: &'static str, @@ -1319,7 +1323,13 @@ pub fn evaluate_relation_output( for eval in evals { scratch.insert(eval.name, eval.value); } - for polynomial_eval in plan.polynomial_evals { + for polynomial_eval_symbol in plan.structured_polynomial_evals { + let polynomial_eval = relation_output_values + .iter() + .find(|value| value.symbol == *polynomial_eval_symbol) + .ok_or(RuntimePlanError::MissingValue { + symbol: polynomial_eval_symbol, + })?; let x_raw_point = relation_output_x_point_source( polynomial_eval.x_point.source, instance_symbol, @@ -1367,6 +1377,7 @@ pub fn evaluate_relation_output( pub fn evaluate_relation_output_for_instance( relation_outputs: &[RelationOutputPlan], + relation_output_values: &[StructuredPolynomialEvalPlan], field_exprs: &[FieldExprPlan], store: &ValueStore, instance: &SumcheckInstanceResultPlan, @@ -1384,6 +1395,7 @@ pub fn evaluate_relation_output_for_instance( })?; evaluate_relation_output( relation_output, + relation_output_values, field_exprs, store, instance.symbol, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index edfcebd230..132136d1bf 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -1,42 +1,29 @@ use crate::emit::rust::{push_format, EmitError}; use crate::ir::Role; use crate::protocols::jolt::verifier_relation_outputs::{ - RelationOutputFunctionKind, RelationOutputPlan, StructuredPolynomialKind, - StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment, + RelationOutputFunctionKind, RelationOutputPlan, StructuredPolynomialEvalPlan, + StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, }; pub fn emit_verifier_relation_output_constants( stage_type: &str, role: &Role, + relation_output_values: &[StructuredPolynomialEvalPlan], relation_outputs: &[RelationOutputPlan], ) -> Result { let mut source = String::new(); + emit_relation_output_value_constants(&mut source, stage_type, relation_output_values)?; let mut claims = Vec::new(); for (index, claim) in relation_outputs.iter().enumerate() { let values_name = format!( - "{}_RELATION_OUTPUT_{index}_VALUES", + "{}_RELATION_OUTPUT_{index}_STRUCTURED_POLYNOMIAL_EVALS", stage_type.to_ascii_uppercase() ); - let values = claim - .polynomial_evals - .iter() - .map(|value| { - Ok(format!( - " {stage_type}StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", - rust_str(&value.symbol), - structured_polynomial_kind_expr(stage_type, value.polynomial), - structured_polynomial_point_expr(stage_type, &value.x_point), - structured_polynomial_point_expr(stage_type, &value.y_point), - )) - }) - .collect::, EmitError>>()? - .join("\n"); - push_format( + let values = emit_str_slice_or_inline( &mut source, - format_args!( - "pub const {values_name}: &[{stage_type}StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" - ), + &values_name, + &claim.structured_polynomial_evals, ); let eval_families = emit_eval_family_constants(&mut source, stage_type, index, claim); let product_families = emit_product_family_constants(&mut source, stage_type, index, claim); @@ -44,7 +31,7 @@ pub fn emit_verifier_relation_output_constants( emit_function_family_constants(&mut source, stage_type, index, claim)?; let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim); claims.push(format!( - " {stage_type}RelationOutputPlan {{ relation: {}, polynomial_evals: {values_name}, eval_families: {eval_families}, product_families: {product_families}, function_families: {function_families}, local_scalars: {local_scalars}, expected_output: {} }},", + " {stage_type}RelationOutputPlan {{ relation: {}, structured_polynomial_evals: {values}, eval_families: {eval_families}, product_families: {product_families}, function_families: {function_families}, local_scalars: {local_scalars}, expected_output: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, rust_str(&claim.expected_output) )); @@ -60,6 +47,34 @@ pub fn emit_verifier_relation_output_constants( Ok(source) } +fn emit_relation_output_value_constants( + source: &mut String, + stage_type: &str, + relation_output_values: &[StructuredPolynomialEvalPlan], +) -> Result<(), EmitError> { + let values_name = format!("{}_RELATION_OUTPUT_VALUES", stage_type.to_ascii_uppercase()); + let values = relation_output_values + .iter() + .map(|value| { + Ok(format!( + " {stage_type}StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", + rust_str(&value.symbol), + structured_polynomial_kind_expr(stage_type, value.polynomial), + structured_polynomial_point_expr(stage_type, &value.x_point), + structured_polynomial_point_expr(stage_type, &value.y_point), + )) + }) + .collect::, EmitError>>()? + .join("\n"); + push_format( + source, + format_args!( + "pub const {values_name}: &[{stage_type}StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" + ), + ); + Ok(()) +} + fn emit_local_scalar_constants( source: &mut String, stage_type: &str, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index dd226ce474..90bf871d71 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1237,6 +1237,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); \x20 drivers: STAGE3_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE3_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE3_SUMCHECK_EVALS,\n\ + \x20 relation_output_values: STAGE3_RELATION_OUTPUT_VALUES,\n\ \x20 relation_outputs: STAGE3_RELATION_OUTPUTS,\n\ \x20 point_slices: STAGE3_POINT_SLICES,\n\ \x20 point_concats: STAGE3_POINT_CONCATS,\n\ @@ -1709,6 +1710,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); super::relation_outputs::emit_verifier_relation_output_constants( "Stage3", &self.role, + &self.relation_output_values, &self.relation_outputs, ) } @@ -2172,6 +2174,7 @@ fn expected_batched_output_claim( })?; let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 43db1a0afe..ea8b4b977a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -1422,7 +1422,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); source.push_str(&self.emit_verifier_relation_output_constants()?); } let relation_outputs_field = if self.role == Role::Verifier { - " relation_outputs: STAGE4_RELATION_OUTPUTS,\n" + " relation_output_values: STAGE4_RELATION_OUTPUT_VALUES,\n relation_outputs: STAGE4_RELATION_OUTPUTS,\n" } else { "" }; @@ -1938,6 +1938,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); super::relation_outputs::emit_verifier_relation_output_constants( "Stage4", &self.role, + &self.relation_output_values, &self.relation_outputs, ) } @@ -2414,6 +2415,7 @@ fn expected_batched_output_claim( })?; let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 2be8c9b15a..0825f4f9c7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -655,6 +655,7 @@ impl Stage5CpuProgram { let output_plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&indexed_eval_families)? .relation_output_plan(); + relation_output_values.extend(output_plan.relation_output_values); field_exprs.extend(output_plan.field_exprs.into_iter().map(stage5_field_expr)); relation_outputs.push(output_plan.claim); } @@ -814,7 +815,7 @@ impl Stage5CpuProgram { values.extend( self.relation_outputs .iter() - .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), + .flat_map(|claim| claim.structured_polynomial_evals.iter()), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( @@ -1530,7 +1531,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); source.push_str(&self.emit_verifier_relation_output_constants()?); } let relation_outputs_field = if self.role == Role::Verifier { - " relation_outputs: STAGE5_RELATION_OUTPUTS,\n" + " relation_output_values: STAGE5_RELATION_OUTPUT_VALUES,\n relation_outputs: STAGE5_RELATION_OUTPUTS,\n" } else { "" }; @@ -2039,6 +2040,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); super::relation_outputs::emit_verifier_relation_output_constants( "Stage5", &self.role, + &self.relation_output_values, &self.relation_outputs, ) } @@ -2513,6 +2515,7 @@ fn expected_batched_output_claim( )?; bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, @@ -2526,6 +2529,7 @@ fn expected_batched_output_claim( | Stage5RelationKind::Stage5RegistersValEvaluation => { bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 2fe8e3406e..7370dc190f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -852,7 +852,7 @@ impl Stage6CpuProgram { values.extend( self.relation_outputs .iter() - .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), + .flat_map(|claim| claim.structured_polynomial_evals.iter()), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( @@ -1637,7 +1637,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&self.emit_verifier_relation_output_constants()?); } let relation_outputs_field = if self.role == Role::Verifier { - " relation_outputs: STAGE6_RELATION_OUTPUTS,\n" + " relation_output_values: STAGE6_RELATION_OUTPUT_VALUES,\n relation_outputs: STAGE6_RELATION_OUTPUTS,\n" } else { "" }; @@ -2149,6 +2149,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); super::relation_outputs::emit_verifier_relation_output_constants( "Stage6", &self.role, + &self.relation_output_values, &self.relation_outputs, ) } @@ -2715,6 +2716,7 @@ fn expected_plan_relation_output( ) -> Result { Ok(bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 9e71c6fd3e..2a29f620c7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1508,7 +1508,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); } source.push_str(&self.emit_tail_constants()?); let relation_outputs_field = if self.role == Role::Verifier { - " relation_outputs: STAGE7_RELATION_OUTPUTS,\n" + " relation_output_values: STAGE7_RELATION_OUTPUT_VALUES,\n relation_outputs: STAGE7_RELATION_OUTPUTS,\n" } else { "" }; @@ -2010,6 +2010,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); super::relation_outputs::emit_verifier_relation_output_constants( "Stage7", &self.role, + &self.relation_output_values, &self.relation_outputs, ) } @@ -2511,6 +2512,7 @@ fn expected_batched_output_claim( Stage7RelationKind::Stage7HammingWeightClaimReduction => { bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index c0206acc92..6acdb1eff7 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -39,7 +39,7 @@ impl Stage5InstructionReadRafEmitPlan { STAGE5_INSTRUCTION_RA_EVAL_FAMILY, )?; Ok(Self { - point: "stage5.instruction_read_raf.point".to_owned(), + point: "stage5.instruction_read_raf.instance".to_owned(), lookup_output_point: "stage5.input.stage2.instruction.LookupOutput".to_owned(), point_values: point_value_plans(table_flag_evals.evals.len()), table_flag_evals: table_flag_evals.clone(), @@ -202,10 +202,11 @@ impl Stage5InstructionReadRafEmitPlan { ]; Stage5InstructionReadRafOutputPlan { + relation_output_values: vec![eq.clone()], field_exprs, claim: RelationOutputPlan { relation: "jolt.stage5.instruction_read_raf".to_owned(), - polynomial_evals: vec![eq], + structured_polynomial_evals: vec![eq.symbol], eval_families: Vec::new(), product_families: vec![table_value_family, ra_product_family], function_families: Vec::new(), @@ -228,6 +229,7 @@ pub(crate) struct Stage5InstructionReadRafPointValueEmitPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Stage5InstructionReadRafOutputPlan { + pub(crate) relation_output_values: Vec, pub(crate) field_exprs: Vec, pub(crate) claim: RelationOutputPlan, } @@ -437,9 +439,9 @@ mod tests { output_plan.claim.expected_output, "stage5.instruction_read_raf.output.claim_expr" ); - assert_eq!(output_plan.claim.polynomial_evals.len(), 1); + assert_eq!(output_plan.claim.structured_polynomial_evals.len(), 1); assert_eq!( - output_plan.claim.polynomial_evals[0].symbol, + output_plan.claim.structured_polynomial_evals[0], "stage5.instruction_read_raf.output.eq.LookupOutputCycle" ); assert_eq!(output_plan.claim.product_families.len(), 2); diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 705d234d24..1650dddbff 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -359,7 +359,7 @@ impl BytecodeReadRafPlan { }; RelationOutputPlan { relation: "jolt.stage6.bytecode_read_raf".to_owned(), - polynomial_evals: Vec::new(), + structured_polynomial_evals: Vec::new(), eval_families: Vec::new(), product_families: vec![product_family.clone()], function_families: Vec::new(), @@ -682,7 +682,7 @@ mod tests { claim.expected_output, "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" ); - assert!(claim.polynomial_evals.is_empty()); + assert!(claim.structured_polynomial_evals.is_empty()); assert!(claim.eval_families.is_empty()); assert_eq!(claim.product_families.len(), 1); assert_eq!(claim.product_families[0].terms.len(), 1); diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index e1d2f03c4f..ff2c23c942 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -309,7 +309,7 @@ impl VerifierStagePlan { values.extend( self.relation_outputs .iter() - .flat_map(|claim| claim.polynomial_evals.iter().map(|value| &value.symbol)), + .flat_map(|claim| claim.structured_polynomial_evals.iter()), VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index eecb1f1594..8de0847f7b 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -249,7 +249,7 @@ pub struct RelationOutputFunctionFamilyPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: String, - pub polynomial_evals: Vec, + pub structured_polynomial_evals: Vec, pub eval_families: Vec, pub product_families: Vec, pub function_families: Vec, @@ -566,14 +566,13 @@ where claim.relation ))); } - let polynomial_evals = claim + let structured_polynomial_evals = claim .polynomial_evals .iter() .map(|symbol| { relation_output_values_by_symbol .get(symbol.as_str()) - .copied() - .cloned() + .map(|_| symbol.clone()) .ok_or_else(|| { EmitError::new(format!( "{stage} relation output for @{} references missing output value @{symbol}", @@ -606,7 +605,7 @@ where .collect(); Ok(RelationOutputPlan { relation: claim.relation, - polynomial_evals, + structured_polynomial_evals, eval_families, product_families, function_families, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 4628d08a3b..2d1cc15123 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1417,7 +1417,7 @@ fn stage5_rust_targets_extract_and_compile() { ); assert_eq!(prover_program.relation_output_values.len(), 4); assert!(prover_program.relation_outputs.is_empty()); - assert_eq!(verifier_program.relation_output_values.len(), 4); + assert_eq!(verifier_program.relation_output_values.len(), 5); assert_eq!(verifier_program.relation_outputs.len(), 3); assert_eq!( prover_program.point_slices.len(), @@ -1722,7 +1722,7 @@ fn stage6_rust_targets_extract_and_compile() { vec![booleanity_function_family.clone()] ); assert_eq!( - booleanity_claims[0].polynomial_evals[0].symbol, + booleanity_claims[0].structured_polynomial_evals[0], "stage6.booleanity.output.eq.InstructionRa0" ); let hamming_claims = verifier_program @@ -1769,7 +1769,7 @@ fn stage6_rust_targets_extract_and_compile() { }) .collect::>(); assert_eq!(bytecode_claims.len(), 1); - assert!(bytecode_claims[0].polynomial_evals.is_empty()); + assert!(bytecode_claims[0].structured_polynomial_evals.is_empty()); assert!(bytecode_claims[0].eval_families.is_empty()); assert_eq!(bytecode_claims[0].product_families.len(), 1); assert_eq!( diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index a7493af1c8..a6fc63fbce 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -619,33 +619,35 @@ macro_rules! define_stage_adapter_impl { .collect(), ), $( + relation_output_values: super::leak_slice( + program + .relation_output_values + .iter() + .map(|value| $module::$relation_output_value { + symbol: super::leak_str(&value.symbol), + polynomial: super::generated_structured_polynomial_kind(value.polynomial.as_str()), + x_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { + source: super::leak_str(&value.x_point.source), + segment: super::generated_structured_polynomial_point_segment(value.x_point.segment.as_str()), + length: super::generated_structured_polynomial_point_length(value.x_point.length.as_str()), + order: super::generated_structured_polynomial_point_order(value.x_point.order.as_str()), + }, + y_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { + source: super::leak_str(&value.y_point.source), + segment: super::generated_structured_polynomial_point_segment(value.y_point.segment.as_str()), + length: super::generated_structured_polynomial_point_length(value.y_point.length.as_str()), + order: super::generated_structured_polynomial_point_order(value.y_point.order.as_str()), + }, + }) + .collect(), + ), relation_outputs: super::leak_slice( program .relation_outputs .iter() .map(|plan| $module::$relation_output { relation: super::generated_relation_kind(&plan.relation), - polynomial_evals: super::leak_slice( - plan.polynomial_evals - .iter() - .map(|value| $module::$relation_output_value { - symbol: super::leak_str(&value.symbol), - polynomial: super::generated_structured_polynomial_kind(value.polynomial.as_str()), - x_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { - source: super::leak_str(&value.x_point.source), - segment: super::generated_structured_polynomial_point_segment(value.x_point.segment.as_str()), - length: super::generated_structured_polynomial_point_length(value.x_point.length.as_str()), - order: super::generated_structured_polynomial_point_order(value.x_point.order.as_str()), - }, - y_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { - source: super::leak_str(&value.y_point.source), - segment: super::generated_structured_polynomial_point_segment(value.y_point.segment.as_str()), - length: super::generated_structured_polynomial_point_length(value.y_point.length.as_str()), - order: super::generated_structured_polynomial_point_order(value.y_point.order.as_str()), - }, - }) - .collect(), - ), + structured_polynomial_evals: super::leak_str_slice(&plan.structured_polynomial_evals), eval_families: super::leak_slice( plan.eval_families .iter() @@ -765,6 +767,10 @@ macro_rules! define_stage_adapter_impl { ), )? $( + relation_output_values: { + let _ = stringify!($empty_relation_outputs); + &[] + }, relation_outputs: { let _ = stringify!($empty_relation_outputs); &[] diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index e7b5220138..90db2b6e1b 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -210,23 +210,17 @@ pub const STAGE3_OPENING_EQUALITIES: &[Stage3OpeningClaimEqualityPlan] = &[ pub const STAGE3_OPENING_BATCHES: &[Stage3OpeningBatchPlan] = &[ Stage3OpeningBatchPlan { symbol: "stage3.openings", stage: "stage3", proof_slot: "stage3.openings", policy: "jolt_stage3_output_order", count: 16, ordered_claims: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"], claim_operands: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"] }, ]; -pub const STAGE3_RELATION_OUTPUT_0_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ +pub const STAGE3_RELATION_OUTPUT_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ Stage3StructuredPolynomialEvalPlan { symbol: "stage3.spartan_shift.output.eq.NextPC", polynomial: Stage3StructuredPolynomialKind::EqPlusOne, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage1.NextPC", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, Stage3StructuredPolynomialEvalPlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", polynomial: Stage3StructuredPolynomialKind::EqPlusOne, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage2.product_virtual.NextIsNoop", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, -]; - -pub const STAGE3_RELATION_OUTPUT_1_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ Stage3StructuredPolynomialEvalPlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", polynomial: Stage3StructuredPolynomialKind::Eq, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.instruction_input.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage2.product_virtual.LeftInstructionInput", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, -]; - -pub const STAGE3_RELATION_OUTPUT_2_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ Stage3StructuredPolynomialEvalPlan { symbol: "stage3.registers.output.eq.RdWriteValue", polynomial: Stage3StructuredPolynomialKind::Eq, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.registers_claim_reduction.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage1.RdWriteValue", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, ]; pub const STAGE3_RELATION_OUTPUTS: &[Stage3RelationOutputPlan] = &[ - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, polynomial_evals: STAGE3_RELATION_OUTPUT_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, polynomial_evals: STAGE3_RELATION_OUTPUT_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, polynomial_evals: STAGE3_RELATION_OUTPUT_2_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, structured_polynomial_evals: &["stage3.spartan_shift.output.eq.NextPC", "stage3.spartan_shift.output.eq.NextIsNoop"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, structured_polynomial_evals: &["stage3.instruction_input.output.eq.LeftInstructionInput"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, structured_polynomial_evals: &["stage3.registers.output.eq.RdWriteValue"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { @@ -241,6 +235,7 @@ pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan drivers: STAGE3_SUMCHECK_DRIVERS, instance_results: STAGE3_SUMCHECK_INSTANCE_RESULTS, evals: STAGE3_SUMCHECK_EVALS, + relation_output_values: STAGE3_RELATION_OUTPUT_VALUES, relation_outputs: STAGE3_RELATION_OUTPUTS, point_slices: STAGE3_POINT_SLICES, point_concats: STAGE3_POINT_CONCATS, @@ -489,6 +484,7 @@ fn expected_batched_output_claim( })?; let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 85f3447aff..de51eff393 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -174,17 +174,14 @@ pub const STAGE4_OPENING_EQUALITIES: &[Stage4OpeningClaimEqualityPlan] = &[ pub const STAGE4_OPENING_BATCHES: &[Stage4OpeningBatchPlan] = &[ Stage4OpeningBatchPlan { symbol: "stage4.openings", stage: "stage4", proof_slot: "stage4.openings", policy: "jolt_stage4_output_order", count: 7, ordered_claims: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"], claim_operands: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"] }, ]; -pub const STAGE4_RELATION_OUTPUT_0_VALUES: &[Stage4StructuredPolynomialEvalPlan] = &[ +pub const STAGE4_RELATION_OUTPUT_VALUES: &[Stage4StructuredPolynomialEvalPlan] = &[ Stage4StructuredPolynomialEvalPlan { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", polynomial: Stage4StructuredPolynomialKind::Eq, x_point: Stage4StructuredPolynomialPointPlan { source: "stage4.registers_read_write.instance", segment: Stage4StructuredPolynomialPointSegment::Prefix, length: Stage4StructuredPolynomialPointLength::YPoint, order: Stage4StructuredPolynomialPointOrder::Reverse }, y_point: Stage4StructuredPolynomialPointPlan { source: "stage4.input.stage3.registers.RdWriteValue", segment: Stage4StructuredPolynomialPointSegment::Full, length: Stage4StructuredPolynomialPointLength::Full, order: Stage4StructuredPolynomialPointOrder::AsIs } }, -]; - -pub const STAGE4_RELATION_OUTPUT_1_VALUES: &[Stage4StructuredPolynomialEvalPlan] = &[ Stage4StructuredPolynomialEvalPlan { symbol: "stage4.ram_val_check.output.lt.RamValCycle", polynomial: Stage4StructuredPolynomialKind::Lt, x_point: Stage4StructuredPolynomialPointPlan { source: "stage4.ram_val_check.instance", segment: Stage4StructuredPolynomialPointSegment::Full, length: Stage4StructuredPolynomialPointLength::Full, order: Stage4StructuredPolynomialPointOrder::Reverse }, y_point: Stage4StructuredPolynomialPointPlan { source: "stage4.input.stage2.RamVal", segment: Stage4StructuredPolynomialPointSegment::Suffix, length: Stage4StructuredPolynomialPointLength::XPoint, order: Stage4StructuredPolynomialPointOrder::AsIs } }, ]; pub const STAGE4_RELATION_OUTPUTS: &[Stage4RelationOutputPlan] = &[ - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, polynomial_evals: STAGE4_RELATION_OUTPUT_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, polynomial_evals: STAGE4_RELATION_OUTPUT_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, structured_polynomial_evals: &["stage4.registers_read_write.output.eq.RdWriteValue"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, structured_polynomial_evals: &["stage4.ram_val_check.output.lt.RamValCycle"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { @@ -202,6 +199,7 @@ pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { drivers: STAGE4_SUMCHECK_DRIVERS, instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS, evals: STAGE4_SUMCHECK_EVALS, + relation_output_values: STAGE4_RELATION_OUTPUT_VALUES, relation_outputs: STAGE4_RELATION_OUTPUTS, point_slices: STAGE4_POINT_SLICES, point_concats: STAGE4_POINT_CONCATS, @@ -466,6 +464,7 @@ fn expected_batched_output_claim( })?; let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 1a0ff1ebc7..726894aa02 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -251,7 +251,7 @@ pub const STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES: &[Stage5InstructionReadRafPo ]; pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan { - point: "stage5.instruction_read_raf.point", + point: "stage5.instruction_read_raf.instance", lookup_output_point: "stage5.input.stage2.instruction.LookupOutput", table_flag_evals: &STAGE5_INDEXED_EVAL_FAMILIES[0], instruction_ra_evals: &STAGE5_INDEXED_EVAL_FAMILIES[1], @@ -359,18 +359,12 @@ pub const STAGE5_INDEXED_EVAL_FAMILIES: &[bolt_verifier_runtime::NamedEvalFamily bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.InstructionRa", evals: STAGE5_INDEXED_EVAL_FAMILY_1_NAMES }, ]; -pub const STAGE5_RELATION_OUTPUT_0_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ +pub const STAGE5_RELATION_OUTPUT_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.ram_raf.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.ram_read_write.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage4.ram_val_check.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, -]; - -pub const STAGE5_RELATION_OUTPUT_1_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ Stage5StructuredPolynomialEvalPlan { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", polynomial: Stage5StructuredPolynomialKind::Lt, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.registers_val_evaluation.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage4.registers.RegistersVal", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, -]; - -pub const STAGE5_RELATION_OUTPUT_2_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ - Stage5StructuredPolynomialEvalPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.instruction_read_raf.point", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::YPoint, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.instruction.LookupOutput", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::AsIs } }, + Stage5StructuredPolynomialEvalPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.instruction_read_raf.instance", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::YPoint, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.instruction.LookupOutput", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::AsIs } }, ]; pub const STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ @@ -426,9 +420,9 @@ pub const STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::Re pub const STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; pub const STAGE5_RELATION_OUTPUTS: &[Stage5RelationOutputPlan] = &[ - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, polynomial_evals: STAGE5_RELATION_OUTPUT_0_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, polynomial_evals: STAGE5_RELATION_OUTPUT_1_VALUES, eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, polynomial_evals: STAGE5_RELATION_OUTPUT_2_VALUES, eval_families: &[], product_families: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, structured_polynomial_evals: &["stage5.ram_ra_claim_reduction.output.eq.Raf", "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", "stage5.ram_ra_claim_reduction.output.eq.ValCheck"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, structured_polynomial_evals: &["stage5.registers_val_evaluation.output.lt.RegistersValCycle"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, structured_polynomial_evals: &["stage5.instruction_read_raf.output.eq.LookupOutputCycle"], eval_families: &[], product_families: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { @@ -446,6 +440,7 @@ pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { drivers: STAGE5_SUMCHECK_DRIVERS, instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS, evals: STAGE5_SUMCHECK_EVALS, + relation_output_values: STAGE5_RELATION_OUTPUT_VALUES, relation_outputs: STAGE5_RELATION_OUTPUTS, point_slices: STAGE5_POINT_SLICES, point_concats: STAGE5_POINT_CONCATS, @@ -723,6 +718,7 @@ fn expected_batched_output_claim( )?; bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, @@ -736,6 +732,7 @@ fn expected_batched_output_claim( | Stage5RelationKind::Stage5RegistersValEvaluation => { bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index cd7449805b..a25d3df283 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -633,8 +633,15 @@ const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafP }, entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; -pub const STAGE6_RELATION_OUTPUT_0_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ +pub const STAGE6_RELATION_OUTPUT_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ Stage6StructuredPolynomialEvalPlan { symbol: "stage6.booleanity.output.eq.InstructionRa0", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.output.point", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.hamming_booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage1.LookupOutput", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.ram_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.instruction_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage2.ram_read_write.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.ram_val_check.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.registers_read_write.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, + Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.registers_val_evaluation.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; pub const STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan] = &[ @@ -682,10 +689,6 @@ pub const STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::R bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { symbol: "stage6.booleanity.output.family", gamma: Some("stage6.booleanity.gamma"), terms: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILY_0_TERMS }, ]; -pub const STAGE6_RELATION_OUTPUT_1_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.hamming_booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage1.LookupOutput", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse } }, -]; - pub const STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan] = &[ bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.hamming_booleanity.eval.HammingWeight", factors: &["stage6.hamming_booleanity.output.eq.LookupOutput"] }, ]; @@ -693,10 +696,6 @@ pub const STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILIES: &[bolt_verifier_runtime::R bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { symbol: "stage6.hamming_booleanity.output.family", gamma: None, terms: STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILY_0_TERMS }, ]; -pub const STAGE6_RELATION_OUTPUT_2_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.ram_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, -]; - pub const STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"], eval_families: &[], factors: &["stage6.ram_ra_virtual.output.eq.Cycle"] }, ]; @@ -704,10 +703,6 @@ pub const STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::Re bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: None, terms: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS }, ]; -pub const STAGE6_RELATION_OUTPUT_3_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.instruction_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, -]; - pub const STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, @@ -722,13 +717,6 @@ pub const STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES: &[bolt_verifier_runtime::Re bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: Some("stage6.instruction_ra_virtual.gamma"), terms: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILY_0_TERMS }, ]; -pub const STAGE6_RELATION_OUTPUT_4_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage2.ram_read_write.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.ram_val_check.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.registers_read_write.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.registers_val_evaluation.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, -]; - pub const STAGE6_RELATION_OUTPUT_4_FAMILY_0_EVALS: &[&str] = &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.eval.RdInc"]; pub const STAGE6_RELATION_OUTPUT_4_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan] = &[ @@ -741,10 +729,6 @@ pub const STAGE6_RELATION_OUTPUT_4_FAMILIES: &[bolt_verifier_runtime::RelationOu bolt_verifier_runtime::RelationOutputEvalFamilyPlan { symbol: "stage6.inc_claim_reduction.output.family", gamma: "stage6.inc_claim_reduction.gamma", evals: STAGE6_RELATION_OUTPUT_4_FAMILY_0_EVALS, power_stride: 2, value_term_offsets: &[], shared_terms: STAGE6_RELATION_OUTPUT_4_FAMILY_0_SHARED_TERMS, item_terms: STAGE6_RELATION_OUTPUT_4_FAMILY_0_ITEM_TERMS }, ]; -pub const STAGE6_RELATION_OUTPUT_5_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ - -]; - pub const STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.bytecode_read_raf.output.contribution"], eval_families: &["stage6.bytecode_read_raf.eval.BytecodeRa"], factors: &[] }, ]; @@ -754,12 +738,12 @@ pub const STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES: &[bolt_verifier_runtime::Re pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, polynomial_evals: STAGE6_RELATION_OUTPUT_0_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, polynomial_evals: STAGE6_RELATION_OUTPUT_1_VALUES, eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, polynomial_evals: STAGE6_RELATION_OUTPUT_2_VALUES, eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, polynomial_evals: STAGE6_RELATION_OUTPUT_3_VALUES, eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, polynomial_evals: STAGE6_RELATION_OUTPUT_4_VALUES, eval_families: STAGE6_RELATION_OUTPUT_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, polynomial_evals: STAGE6_RELATION_OUTPUT_5_VALUES, eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &["stage6.booleanity.output.eq.InstructionRa0"], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &["stage6.hamming_booleanity.output.eq.LookupOutput"], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &["stage6.ram_ra_virtual.output.eq.Cycle"], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &["stage6.instruction_ra_virtual.output.eq.Cycle"], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.eq.RamIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage5"], eval_families: STAGE6_RELATION_OUTPUT_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { @@ -777,6 +761,7 @@ pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { drivers: STAGE6_SUMCHECK_DRIVERS, instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS, evals: STAGE6_SUMCHECK_EVALS, + relation_output_values: STAGE6_RELATION_OUTPUT_VALUES, relation_outputs: STAGE6_RELATION_OUTPUTS, point_zeros: STAGE6_POINT_ZEROS, point_slices: STAGE6_POINT_SLICES, @@ -1120,6 +1105,7 @@ fn expected_plan_relation_output( ) -> Result { Ok(bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index a8314584c6..9c9c3d9d22 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -229,7 +229,7 @@ pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_DRIVERS: &[Stage7SumcheckDriverPlan] = &[ Stage7SumcheckDriverPlan { symbol: "stage7.sumcheck", stage: "stage7", proof_slot: "stage7.sumcheck", kernel: None, relation: Some(Stage7RelationKind::Stage7Batched), batch: "stage7.batch", policy: "jolt_core_stage7_aligned", round_schedule: STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 4, degree: 2 }, ]; -pub const STAGE7_RELATION_OUTPUT_0_VALUES: &[Stage7StructuredPolynomialEvalPlan] = &[ +pub const STAGE7_RELATION_OUTPUT_VALUES: &[Stage7StructuredPolynomialEvalPlan] = &[ Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.booleanity.InstructionRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, @@ -272,6 +272,7 @@ pub const STAGE7_RELATION_OUTPUT_0_VALUES: &[Stage7StructuredPolynomialEvalPlan] Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_3", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, ]; +pub const STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS: &[&str] = &["stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]; pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS: &[&str] = &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3"]; pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan] = &[ bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan { gamma_power_offset: 1, factor: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity" }, @@ -285,7 +286,7 @@ pub const STAGE7_RELATION_OUTPUT_0_FAMILIES: &[bolt_verifier_runtime::RelationOu ]; pub const STAGE7_RELATION_OUTPUTS: &[Stage7RelationOutputPlan] = &[ - Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, polynomial_evals: STAGE7_RELATION_OUTPUT_0_VALUES, eval_families: STAGE7_RELATION_OUTPUT_0_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.family" }, + Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, structured_polynomial_evals: STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS, eval_families: STAGE7_RELATION_OUTPUT_0_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.family" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ @@ -385,6 +386,7 @@ pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan { drivers: STAGE7_SUMCHECK_DRIVERS, instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS, evals: STAGE7_SUMCHECK_EVALS, + relation_output_values: STAGE7_RELATION_OUTPUT_VALUES, relation_outputs: STAGE7_RELATION_OUTPUTS, point_zeros: STAGE7_POINT_ZEROS, point_slices: STAGE7_POINT_SLICES, @@ -663,6 +665,7 @@ fn expected_batched_output_claim( Stage7RelationKind::Stage7HammingWeightClaimReduction => { bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, + program.relation_output_values, program.field_exprs, store, instance, From f42a1ac48c2844cb156b1ff9fd7785aa11a329ea Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 19:35:26 -0600 Subject: [PATCH 098/171] refactor(bolt): resolve relation output refs --- crates/bolt-verifier-runtime/src/lib.rs | 25 ++++++++--- .../jolt/emit/rust/relation_outputs.rs | 41 ++++++++++++++++-- .../src/protocols/jolt/emit/rust/stage5.rs | 16 +++++-- .../src/protocols/jolt/emit/rust/stage6.rs | 9 ++-- .../jolt/stage5_instruction_read_raf_plan.rs | 12 ++++-- .../bolt/src/protocols/jolt/verifier_plan.rs | 9 ++-- .../jolt/verifier_relation_outputs.rs | 16 +++++-- crates/bolt/tests/commitment_ir.rs | 3 +- crates/jolt-equivalence/src/plan_adapters.rs | 10 ++++- crates/jolt-verifier/src/stages/stage3.rs | 6 +-- crates/jolt-verifier/src/stages/stage4.rs | 4 +- crates/jolt-verifier/src/stages/stage5.rs | 6 +-- crates/jolt-verifier/src/stages/stage6.rs | 10 ++--- crates/jolt-verifier/src/stages/stage7.rs | 43 ++++++++++++++++++- 14 files changed, 168 insertions(+), 42 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 7dc7919755..94b598d497 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -378,6 +378,12 @@ pub struct StructuredPolynomialEvalPlan { pub y_point: StructuredPolynomialPointPlan, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct StructuredPolynomialEvalRef { + pub symbol: &'static str, + pub index: usize, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct RelationOutputEvalFamilySharedTermPlan { pub gamma_power_offset: usize, @@ -439,7 +445,7 @@ pub struct RelationOutputFunctionFamilyPlan { #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: R, - pub structured_polynomial_evals: &'static [&'static str], + pub structured_polynomial_evals: &'static [StructuredPolynomialEvalRef], pub eval_families: &'static [RelationOutputEvalFamilyPlan], pub product_families: &'static [RelationOutputProductFamilyPlan], pub function_families: &'static [RelationOutputFunctionFamilyPlan], @@ -1323,13 +1329,20 @@ pub fn evaluate_relation_output( for eval in evals { scratch.insert(eval.name, eval.value); } - for polynomial_eval_symbol in plan.structured_polynomial_evals { + for polynomial_eval_ref in plan.structured_polynomial_evals { let polynomial_eval = relation_output_values - .iter() - .find(|value| value.symbol == *polynomial_eval_symbol) - .ok_or(RuntimePlanError::MissingValue { - symbol: polynomial_eval_symbol, + .get(polynomial_eval_ref.index) + .ok_or(RuntimePlanError::InvalidInputLength { + input: polynomial_eval_ref.symbol, + expected: polynomial_eval_ref.index + 1, + actual: relation_output_values.len(), })?; + if polynomial_eval.symbol != polynomial_eval_ref.symbol { + return Err(RuntimePlanError::InvalidProof { + driver: instance_symbol, + reason: "relation output value reference mismatch", + }); + } let x_raw_point = relation_output_x_point_source( polynomial_eval.x_point.source, instance_symbol, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index 132136d1bf..a7c66c231f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -2,8 +2,9 @@ use crate::emit::rust::{push_format, EmitError}; use crate::ir::Role; use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputFunctionKind, RelationOutputPlan, StructuredPolynomialEvalPlan, - StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, + StructuredPolynomialEvalRefPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, + StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment, }; pub fn emit_verifier_relation_output_constants( @@ -20,7 +21,7 @@ pub fn emit_verifier_relation_output_constants( "{}_RELATION_OUTPUT_{index}_STRUCTURED_POLYNOMIAL_EVALS", stage_type.to_ascii_uppercase() ); - let values = emit_str_slice_or_inline( + let values = emit_structured_polynomial_eval_refs_slice_or_inline( &mut source, &values_name, &claim.structured_polynomial_evals, @@ -284,6 +285,40 @@ fn relation_output_function_kind_expr(function: RelationOutputFunctionKind) -> & } } +fn emit_structured_polynomial_eval_refs_slice_or_inline( + source: &mut String, + name: &str, + values: &[StructuredPolynomialEvalRefPlan], +) -> String { + let rows = values + .iter() + .map(structured_polynomial_eval_ref_expr) + .collect::>(); + if values.len() <= 4 { + return format!("&[{}]", rows.join(", ")); + } + let rows = rows + .into_iter() + .map(|row| format!(" {row},")) + .collect::>() + .join("\n"); + push_format( + source, + format_args!( + "pub const {name}: &[bolt_verifier_runtime::StructuredPolynomialEvalRef] = &[\n{rows}\n];\n" + ), + ); + name.to_owned() +} + +fn structured_polynomial_eval_ref_expr(value: &StructuredPolynomialEvalRefPlan) -> String { + format!( + "bolt_verifier_runtime::StructuredPolynomialEvalRef {{ symbol: {}, index: {} }}", + rust_str(&value.symbol), + value.index + ) +} + fn emit_str_slice_or_inline(source: &mut String, name: &str, values: &[String]) -> String { if values.len() <= 4 { return format!("&[{}]", rust_str_array(values)); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 0825f4f9c7..f3d098d82c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -655,9 +655,14 @@ impl Stage5CpuProgram { let output_plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&indexed_eval_families)? .relation_output_plan(); + let relation_output_value_base = relation_output_values.len(); + let mut output_claim = output_plan.claim; + for value_ref in &mut output_claim.structured_polynomial_evals { + value_ref.index += relation_output_value_base; + } relation_output_values.extend(output_plan.relation_output_values); field_exprs.extend(output_plan.field_exprs.into_iter().map(stage5_field_expr)); - relation_outputs.push(output_plan.claim); + relation_outputs.push(output_claim); } let mut program = Self { @@ -813,9 +818,12 @@ impl Stage5CpuProgram { verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.structured_polynomial_evals.iter()), + self.relation_outputs.iter().flat_map(|claim| { + claim + .structured_polynomial_evals + .iter() + .map(|value| &value.symbol) + }), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 7370dc190f..633cfeb2b9 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -850,9 +850,12 @@ impl Stage6CpuProgram { verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.structured_polynomial_evals.iter()), + self.relation_outputs.iter().flat_map(|claim| { + claim + .structured_polynomial_evals + .iter() + .map(|value| &value.symbol) + }), verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 6acdb1eff7..cb574dfa70 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -2,8 +2,8 @@ use crate::emit::rust::{push_format, EmitError}; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputPlan, RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, - StructuredPolynomialEvalPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, - StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, + StructuredPolynomialEvalPlan, StructuredPolynomialEvalRefPlan, StructuredPolynomialKind, + StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, }; @@ -206,7 +206,10 @@ impl Stage5InstructionReadRafEmitPlan { field_exprs, claim: RelationOutputPlan { relation: "jolt.stage5.instruction_read_raf".to_owned(), - structured_polynomial_evals: vec![eq.symbol], + structured_polynomial_evals: vec![StructuredPolynomialEvalRefPlan { + symbol: eq.symbol, + index: 0, + }], eval_families: Vec::new(), product_families: vec![table_value_family, ra_product_family], function_families: Vec::new(), @@ -441,9 +444,10 @@ mod tests { ); assert_eq!(output_plan.claim.structured_polynomial_evals.len(), 1); assert_eq!( - output_plan.claim.structured_polynomial_evals[0], + output_plan.claim.structured_polynomial_evals[0].symbol, "stage5.instruction_read_raf.output.eq.LookupOutputCycle" ); + assert_eq!(output_plan.claim.structured_polynomial_evals[0].index, 0); assert_eq!(output_plan.claim.product_families.len(), 2); assert_eq!( output_plan.claim.product_families[0].symbol, diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index ff2c23c942..5cbd61c2b7 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -307,9 +307,12 @@ impl VerifierStagePlan { VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.structured_polynomial_evals.iter()), + self.relation_outputs.iter().flat_map(|claim| { + claim + .structured_polynomial_evals + .iter() + .map(|value| &value.symbol) + }), VerifierScalarSourceKind::StructuredPolynomialEval, ); values.extend( diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 8de0847f7b..53b3894897 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -193,6 +193,12 @@ impl StructuredPolynomialEvalPlan { } } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct StructuredPolynomialEvalRefPlan { + pub symbol: String, + pub index: usize, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputEvalFamilySharedTermPlan { pub gamma_power_offset: usize, @@ -249,7 +255,7 @@ pub struct RelationOutputFunctionFamilyPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: String, - pub structured_polynomial_evals: Vec, + pub structured_polynomial_evals: Vec, pub eval_families: Vec, pub product_families: Vec, pub function_families: Vec, @@ -531,7 +537,8 @@ where { let relation_output_values_by_symbol: BTreeMap<_, _> = relation_output_values .iter() - .map(|value| (value.symbol.as_str(), value)) + .enumerate() + .map(|(index, value)| (value.symbol.as_str(), index)) .collect(); let relation_output_eval_families_by_symbol: BTreeMap<_, _> = relation_output_eval_families .iter() @@ -572,7 +579,10 @@ where .map(|symbol| { relation_output_values_by_symbol .get(symbol.as_str()) - .map(|_| symbol.clone()) + .map(|&index| StructuredPolynomialEvalRefPlan { + symbol: symbol.clone(), + index, + }) .ok_or_else(|| { EmitError::new(format!( "{stage} relation output for @{} references missing output value @{symbol}", diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 2d1cc15123..7190b9ba5b 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1722,9 +1722,10 @@ fn stage6_rust_targets_extract_and_compile() { vec![booleanity_function_family.clone()] ); assert_eq!( - booleanity_claims[0].structured_polynomial_evals[0], + booleanity_claims[0].structured_polynomial_evals[0].symbol, "stage6.booleanity.output.eq.InstructionRa0" ); + assert_eq!(booleanity_claims[0].structured_polynomial_evals[0].index, 0); let hamming_claims = verifier_program .relation_outputs .iter() diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index a6fc63fbce..03dba5ad2a 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -647,7 +647,15 @@ macro_rules! define_stage_adapter_impl { .iter() .map(|plan| $module::$relation_output { relation: super::generated_relation_kind(&plan.relation), - structured_polynomial_evals: super::leak_str_slice(&plan.structured_polynomial_evals), + structured_polynomial_evals: super::leak_slice( + plan.structured_polynomial_evals + .iter() + .map(|value| bolt_verifier_runtime::StructuredPolynomialEvalRef { + symbol: super::leak_str(&value.symbol), + index: value.index, + }) + .collect(), + ), eval_families: super::leak_slice( plan.eval_families .iter() diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 90db2b6e1b..88f71aecde 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -218,9 +218,9 @@ pub const STAGE3_RELATION_OUTPUT_VALUES: &[Stage3StructuredPolynomialEvalPlan] = ]; pub const STAGE3_RELATION_OUTPUTS: &[Stage3RelationOutputPlan] = &[ - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, structured_polynomial_evals: &["stage3.spartan_shift.output.eq.NextPC", "stage3.spartan_shift.output.eq.NextIsNoop"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, structured_polynomial_evals: &["stage3.instruction_input.output.eq.LeftInstructionInput"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, structured_polynomial_evals: &["stage3.registers.output.eq.RdWriteValue"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextPC", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", index: 1 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", index: 2 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.registers.output.eq.RdWriteValue", index: 3 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index de51eff393..f33a64beb3 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -180,8 +180,8 @@ pub const STAGE4_RELATION_OUTPUT_VALUES: &[Stage4StructuredPolynomialEvalPlan] = ]; pub const STAGE4_RELATION_OUTPUTS: &[Stage4RelationOutputPlan] = &[ - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, structured_polynomial_evals: &["stage4.registers_read_write.output.eq.RdWriteValue"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, structured_polynomial_evals: &["stage4.ram_val_check.output.lt.RamValCycle"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", index: 0 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.ram_val_check.output.lt.RamValCycle", index: 1 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 726894aa02..693aab6b8a 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -420,9 +420,9 @@ pub const STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::Re pub const STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; pub const STAGE5_RELATION_OUTPUTS: &[Stage5RelationOutputPlan] = &[ - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, structured_polynomial_evals: &["stage5.ram_ra_claim_reduction.output.eq.Raf", "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", "stage5.ram_ra_claim_reduction.output.eq.ValCheck"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, structured_polynomial_evals: &["stage5.registers_val_evaluation.output.lt.RegistersValCycle"], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, structured_polynomial_evals: &["stage5.instruction_read_raf.output.eq.LookupOutputCycle"], eval_families: &[], product_families: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", index: 1 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", index: 2 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", index: 3 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", index: 4 }], eval_families: &[], product_families: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index a25d3df283..14f426d7df 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -738,11 +738,11 @@ pub const STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES: &[bolt_verifier_runtime::Re pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &["stage6.booleanity.output.eq.InstructionRa0"], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &["stage6.hamming_booleanity.output.eq.LookupOutput"], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &["stage6.ram_ra_virtual.output.eq.Cycle"], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &["stage6.instruction_ra_virtual.output.eq.Cycle"], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.eq.RamIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage5"], eval_families: STAGE6_RELATION_OUTPUT_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: STAGE6_RELATION_OUTPUT_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.family" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, ]; diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 9c9c3d9d22..f8683f3458 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -272,7 +272,48 @@ pub const STAGE7_RELATION_OUTPUT_VALUES: &[Stage7StructuredPolynomialEvalPlan] = Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_3", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS: &[&str] = &["stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]; +pub const STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS: &[bolt_verifier_runtime::StructuredPolynomialEvalRef] = &[ + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", index: 0 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", index: 1 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", index: 2 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", index: 3 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", index: 4 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", index: 5 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", index: 6 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", index: 7 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", index: 8 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", index: 9 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", index: 10 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", index: 11 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", index: 12 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", index: 13 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", index: 14 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", index: 15 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", index: 16 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", index: 17 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", index: 18 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", index: 19 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", index: 20 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", index: 21 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", index: 22 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", index: 23 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", index: 24 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", index: 25 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", index: 26 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", index: 27 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", index: 28 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", index: 29 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", index: 30 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", index: 31 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", index: 32 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", index: 33 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", index: 34 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", index: 35 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", index: 36 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", index: 37 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", index: 38 }, + bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", index: 39 }, +]; pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS: &[&str] = &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3"]; pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan] = &[ bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan { gamma_power_offset: 1, factor: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity" }, From b6f028d90b83ee33493b460ab64c5cb68e9c8fa7 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 19:46:23 -0600 Subject: [PATCH 099/171] refactor(bolt): lower hamming output scalar --- .../src/protocols/jolt/emit/rust/stage6.rs | 77 +++++++++++++++++++ crates/bolt/tests/commitment_ir.rs | 50 ++++++------ crates/jolt-verifier/src/stages/stage6.rs | 11 +-- 3 files changed, 102 insertions(+), 36 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 633cfeb2b9..20bd617608 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -673,6 +673,13 @@ impl Stage6CpuProgram { .map(|claim| claim.expected_output.as_str()), ); } + if role == Role::Verifier { + lower_stage6_hamming_booleanity_output( + &mut field_exprs, + &mut relation_output_function_families, + &mut relation_output_asts, + )?; + } let mut relation_outputs = if role == Role::Verifier { verifier_relation_outputs::resolve_relation_outputs( "stage6", @@ -2754,6 +2761,76 @@ fn stage6_trace_rounds( } } +fn lower_stage6_hamming_booleanity_output( + field_exprs: &mut Vec, + relation_output_function_families: &mut Vec, + relation_output_asts: &mut [Stage6RelationOutputAst], +) -> Result<(), EmitError> { + let Some(claim) = relation_output_asts + .iter_mut() + .find(|claim| claim.relation == "jolt.stage6.hamming_booleanity") + else { + return Ok(()); + }; + let family_symbol = claim.expected_output.clone(); + let Some(family_index) = relation_output_function_families + .iter() + .position(|family| family.symbol == family_symbol) + else { + return Err(EmitError::new(format!( + "stage6 hamming booleanity output references missing function family @{family_symbol}" + ))); + }; + let family = &relation_output_function_families[family_index]; + if family.gamma.is_some() || family.terms.len() != 1 { + return Err(EmitError::new(format!( + "stage6 hamming booleanity output family @{family_symbol} must be one ungamified term" + ))); + } + let term = &family.terms[0]; + if term.gamma_power_offset != 0 || term.function != "boolean_zero" || term.factors.len() != 1 { + return Err(EmitError::new(format!( + "stage6 hamming booleanity output family @{family_symbol} has unsupported term shape" + ))); + } + + let square = "stage6.hamming_booleanity.output.boolean_zero.square"; + let boolean_zero = "stage6.hamming_booleanity.output.boolean_zero"; + let claim_expr = "stage6.hamming_booleanity.output.claim_expr"; + field_exprs.push(stage6_relation_output_expr( + square, + "field.mul", + vec![term.eval.clone(), term.eval.clone()], + )); + field_exprs.push(stage6_relation_output_expr( + boolean_zero, + "field.sub", + vec![square.to_owned(), term.eval.clone()], + )); + field_exprs.push(stage6_relation_output_expr( + claim_expr, + "field.mul", + vec![boolean_zero.to_owned(), term.factors[0].clone()], + )); + claim_expr.clone_into(&mut claim.expected_output); + let _removed_family = relation_output_function_families.remove(family_index); + Ok(()) +} + +fn stage6_relation_output_expr( + symbol: &str, + formula: &str, + operands: Vec, +) -> Stage6FieldExprPlan { + Stage6FieldExprPlan { + symbol: symbol.to_owned(), + kind: "op".to_owned(), + formula: formula.to_owned(), + operand_names: operands.clone(), + operands, + } +} + fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { STAGE6_KERNEL_ABIS .iter() diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 7190b9ba5b..69d3629d30 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1558,7 +1558,7 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(verifier_program.relation_output_values.len(), 8); assert_eq!(verifier_program.relation_output_eval_families.len(), 1); assert_eq!(verifier_program.relation_output_product_families.len(), 2); - assert_eq!(verifier_program.relation_output_function_families.len(), 2); + assert_eq!(verifier_program.relation_output_function_families.len(), 1); assert_eq!(verifier_program.relation_outputs.len(), 6); let total_booleanity_ra = params.instruction_d + params.bytecode_d + params.ram_d; let booleanity_function_families = verifier_program @@ -1596,24 +1596,23 @@ fn stage6_rust_targets_extract_and_compile() { booleanity_function_family.terms[0].factors, vec!["stage6.booleanity.output.eq.InstructionRa0".to_owned()] ); - let hamming_function_families = verifier_program + assert!(verifier_program .relation_output_function_families .iter() - .filter(|family| family.symbol == "stage6.hamming_booleanity.output.family") + .all(|family| family.symbol != "stage6.hamming_booleanity.output.family")); + let hamming_expr_symbols = verifier_program + .field_exprs + .iter() + .filter(|expr| expr.symbol.starts_with("stage6.hamming_booleanity.output.")) + .map(|expr| expr.symbol.as_str()) .collect::>(); - assert_eq!(hamming_function_families.len(), 1); - let hamming_function_family = hamming_function_families[0]; - assert_eq!(hamming_function_family.gamma, None); - assert_eq!(hamming_function_family.terms.len(), 1); - assert_eq!(hamming_function_family.terms[0].gamma_power_offset, 0); - assert_eq!(hamming_function_family.terms[0].function, "boolean_zero"); assert_eq!( - hamming_function_family.terms[0].eval, - "stage6.hamming_booleanity.eval.HammingWeight" - ); - assert_eq!( - hamming_function_family.terms[0].factors, - vec!["stage6.hamming_booleanity.output.eq.LookupOutput".to_owned()] + hamming_expr_symbols, + vec![ + "stage6.hamming_booleanity.output.boolean_zero.square", + "stage6.hamming_booleanity.output.boolean_zero", + "stage6.hamming_booleanity.output.claim_expr" + ] ); let ram_product_families = verifier_program .relation_output_product_families @@ -1729,15 +1728,12 @@ fn stage6_rust_targets_extract_and_compile() { let hamming_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.hamming_booleanity.output.family") + .filter(|claim| claim.expected_output == "stage6.hamming_booleanity.output.claim_expr") .collect::>(); assert_eq!(hamming_claims.len(), 1); assert!(hamming_claims[0].eval_families.is_empty()); assert!(hamming_claims[0].product_families.is_empty()); - assert_eq!( - hamming_claims[0].function_families, - vec![hamming_function_family.clone()] - ); + assert!(hamming_claims[0].function_families.is_empty()); let ram_ra_claims = verifier_program .relation_outputs .iter() @@ -1936,9 +1932,15 @@ fn stage6_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("stage6.booleanity.output.gamma_sq_")); - assert!(verifier_source + assert!(!verifier_source .source .contains("stage6.hamming_booleanity.output.family")); + assert!(verifier_source + .source + .contains("stage6.hamming_booleanity.output.claim_expr")); + assert!(verifier_source + .source + .contains("stage6.hamming_booleanity.output.boolean_zero")); assert!(verifier_source .source .contains("stage6.ram_ra_virtual.output.family")); @@ -1954,12 +1956,6 @@ fn stage6_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("stage6.hamming_booleanity.output.neg.HammingWeight")); - assert!(!verifier_source - .source - .contains("stage6.hamming_booleanity.output.boolean")); - assert!(!verifier_source - .source - .contains("stage6.hamming_booleanity.output.claim_expr")); assert!(!verifier_source .source .contains("stage6.hamming_booleanity.output.gamma_identity")); diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 14f426d7df..15ba744804 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -294,7 +294,7 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term3.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), - stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), + stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero.square", Stage6FieldExprKind::Mul, &["stage6.hamming_booleanity.eval.HammingWeight", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.hamming_booleanity.output.boolean_zero.square", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.hamming_booleanity.output.boolean_zero", "stage6.hamming_booleanity.output.eq.LookupOutput"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -689,13 +689,6 @@ pub const STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::R bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { symbol: "stage6.booleanity.output.family", gamma: Some("stage6.booleanity.gamma"), terms: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILY_0_TERMS }, ]; -pub const STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan] = &[ - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.hamming_booleanity.eval.HammingWeight", factors: &["stage6.hamming_booleanity.output.eq.LookupOutput"] }, -]; -pub const STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILIES: &[bolt_verifier_runtime::RelationOutputFunctionFamilyPlan] = &[ - bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { symbol: "stage6.hamming_booleanity.output.family", gamma: None, terms: STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILY_0_TERMS }, -]; - pub const STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"], eval_families: &[], factors: &["stage6.ram_ra_virtual.output.eq.Cycle"] }, ]; @@ -739,7 +732,7 @@ pub const STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES: &[bolt_verifier_runtime::Re pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_1_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.family" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.family" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: STAGE6_RELATION_OUTPUT_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.family" }, From 838a7553f90876eb229ba71bdaed8c2fcab478eb Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 19:56:50 -0600 Subject: [PATCH 100/171] refactor(bolt): lower increment output scalar --- crates/bolt-verifier-runtime/src/lib.rs | 32 +++ .../src/protocols/jolt/emit/rust/stage6.rs | 86 ++---- .../src/protocols/jolt/rust_target_plan.rs | 14 + .../jolt/verifier_relation_outputs.rs | 255 ++++++++++++++++++ crates/bolt/tests/commitment_ir.rs | 75 +++--- crates/jolt-verifier/src/stages/stage6.rs | 17 +- 6 files changed, 370 insertions(+), 109 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 94b598d497..c9a6bdeab2 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -244,6 +244,8 @@ pub enum FieldExprKind { Add, Sub, Mul, + Sum, + Product, Neg, Pow(usize), LagrangeBasisEval(i64, usize, usize), @@ -1720,6 +1722,22 @@ pub fn require_operand_count( } } +pub fn require_min_operand_count( + input: &'static str, + minimum: usize, + actual: usize, +) -> Result<(), RuntimePlanError> { + if actual >= minimum { + Ok(()) + } else { + Err(RuntimePlanError::InvalidInputLength { + input, + expected: minimum, + actual, + }) + } +} + pub fn evaluate_field_expr( expr: &FieldExprPlan, operands: &[F], @@ -1738,6 +1756,20 @@ pub fn evaluate_field_expr( require_operand_count(expr.symbol, 2, operands.len())?; Ok(operands[0] * operands[1]) } + FieldExprKind::Sum => { + require_min_operand_count(expr.symbol, 1, operands.len())?; + Ok(operands + .iter() + .copied() + .fold(F::from_u64(0), |acc, operand| acc + operand)) + } + FieldExprKind::Product => { + require_min_operand_count(expr.symbol, 1, operands.len())?; + Ok(operands + .iter() + .copied() + .fold(F::from_u64(1), |acc, operand| acc * operand)) + } FieldExprKind::Neg => { require_operand_count(expr.symbol, 1, operands.len())?; Ok(-operands[0]) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 20bd617608..840058cad7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -22,6 +22,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ parse_output_product_family_plan, FieldExprDependencies, RelationOutputAst as Stage6RelationOutputAst, RelationOutputEvalFamilyPlan as Stage6RelationOutputEvalFamilyPlan, + RelationOutputFieldExprPlan as Stage6RelationOutputFieldExprPlan, RelationOutputFunctionFamilyPlan as Stage6RelationOutputFunctionFamilyPlan, RelationOutputPlan as Stage6RelationOutputPlan, RelationOutputProductFamilyPlan as Stage6RelationOutputProductFamilyPlan, @@ -674,8 +675,9 @@ impl Stage6CpuProgram { ); } if role == Role::Verifier { - lower_stage6_hamming_booleanity_output( + lower_stage6_relation_outputs( &mut field_exprs, + &mut relation_output_eval_families, &mut relation_output_function_families, &mut relation_output_asts, )?; @@ -2761,71 +2763,41 @@ fn stage6_trace_rounds( } } -fn lower_stage6_hamming_booleanity_output( +fn lower_stage6_relation_outputs( field_exprs: &mut Vec, + relation_output_eval_families: &mut Vec, relation_output_function_families: &mut Vec, relation_output_asts: &mut [Stage6RelationOutputAst], ) -> Result<(), EmitError> { - let Some(claim) = relation_output_asts - .iter_mut() - .find(|claim| claim.relation == "jolt.stage6.hamming_booleanity") - else { - return Ok(()); - }; - let family_symbol = claim.expected_output.clone(); - let Some(family_index) = relation_output_function_families - .iter() - .position(|family| family.symbol == family_symbol) - else { - return Err(EmitError::new(format!( - "stage6 hamming booleanity output references missing function family @{family_symbol}" - ))); - }; - let family = &relation_output_function_families[family_index]; - if family.gamma.is_some() || family.terms.len() != 1 { - return Err(EmitError::new(format!( - "stage6 hamming booleanity output family @{family_symbol} must be one ungamified term" - ))); - } - let term = &family.terms[0]; - if term.gamma_power_offset != 0 || term.function != "boolean_zero" || term.factors.len() != 1 { - return Err(EmitError::new(format!( - "stage6 hamming booleanity output family @{family_symbol} has unsupported term shape" - ))); - } - - let square = "stage6.hamming_booleanity.output.boolean_zero.square"; - let boolean_zero = "stage6.hamming_booleanity.output.boolean_zero"; - let claim_expr = "stage6.hamming_booleanity.output.claim_expr"; - field_exprs.push(stage6_relation_output_expr( - square, - "field.mul", - vec![term.eval.clone(), term.eval.clone()], - )); - field_exprs.push(stage6_relation_output_expr( - boolean_zero, - "field.sub", - vec![square.to_owned(), term.eval.clone()], - )); - field_exprs.push(stage6_relation_output_expr( - claim_expr, - "field.mul", - vec![boolean_zero.to_owned(), term.factors[0].clone()], - )); - claim_expr.clone_into(&mut claim.expected_output); - let _removed_family = relation_output_function_families.remove(family_index); + field_exprs.extend( + verifier_relation_outputs::lower_boolean_zero_function_family_output( + "stage6", + "jolt.stage6.hamming_booleanity", + relation_output_function_families, + relation_output_asts, + )? + .into_iter() + .map(stage6_relation_output_expr), + ); + field_exprs.extend( + verifier_relation_outputs::lower_eval_family_output( + "stage6", + "jolt.stage6.inc_claim_reduction", + relation_output_eval_families, + relation_output_asts, + )? + .into_iter() + .map(stage6_relation_output_expr), + ); Ok(()) } -fn stage6_relation_output_expr( - symbol: &str, - formula: &str, - operands: Vec, -) -> Stage6FieldExprPlan { +fn stage6_relation_output_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage6FieldExprPlan { + let operands = expr.operands; Stage6FieldExprPlan { - symbol: symbol.to_owned(), + symbol: expr.symbol, kind: "op".to_owned(), - formula: formula.to_owned(), + formula: expr.formula, operand_names: operands.clone(), operands, } diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index 8d244864ff..821ad5b616 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -254,6 +254,8 @@ pub(crate) enum FieldExprKind { Add, Sub, Mul, + Sum, + Product, Neg, Pow(usize), LagrangeBasisEval { @@ -270,6 +272,8 @@ impl FieldExprKind { "field.add" => Ok(Self::Add), "field.sub" => Ok(Self::Sub), "field.mul" => Ok(Self::Mul), + "field.sum" => Ok(Self::Sum), + "field.product" => Ok(Self::Product), "field.neg" => Ok(Self::Neg), value if value.starts_with("field.pow:") => parse_pow(value), value if value.starts_with("poly.lagrange_basis_eval:") => parse_lagrange(value), @@ -286,6 +290,8 @@ impl FieldExprKind { Self::Add => "Add".to_owned(), Self::Sub => "Sub".to_owned(), Self::Mul => "Mul".to_owned(), + Self::Sum => "Sum".to_owned(), + Self::Product => "Product".to_owned(), Self::Neg => "Neg".to_owned(), Self::Pow(exponent) => format!("Pow({exponent})"), Self::LagrangeBasisEval { @@ -419,6 +425,14 @@ mod tests { FieldExprKind::from_cpu_attr("field.pow:32").ok(), Some(FieldExprKind::Pow(32)) ); + assert_eq!( + FieldExprKind::from_cpu_attr("field.sum").ok(), + Some(FieldExprKind::Sum) + ); + assert_eq!( + FieldExprKind::from_cpu_attr("field.product").ok(), + Some(FieldExprKind::Product) + ); assert_eq!( FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:-1:3:2").ok(), Some(FieldExprKind::LagrangeBasisEval { diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 53b3894897..2f7e531899 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -271,6 +271,23 @@ pub struct RelationOutputAst { pub expected_output: String, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct RelationOutputFieldExprPlan { + pub symbol: String, + pub formula: String, + pub operands: Vec, +} + +impl FieldExprDependencies for RelationOutputFieldExprPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn operands(&self) -> &[String] { + &self.operands + } +} + pub fn parse_output_eval_family_plan( stage: &str, operation: OperationRef<'_, '_>, @@ -518,6 +535,244 @@ pub fn parse_output_function_family_plan( }) } +pub fn lower_boolean_zero_function_family_output( + stage: &str, + relation: &str, + relation_output_function_families: &mut Vec, + relation_output_asts: &mut [RelationOutputAst], +) -> Result, EmitError> { + let Some(claim) = relation_output_asts + .iter_mut() + .find(|claim| claim.relation == relation) + else { + return Ok(Vec::new()); + }; + let family_symbol = claim.expected_output.clone(); + let family_index = relation_output_function_families + .iter() + .position(|family| family.symbol == family_symbol) + .ok_or_else(|| { + EmitError::new(format!( + "{stage} relation output for @{relation} references missing function family @{family_symbol}" + )) + })?; + let family = relation_output_function_families[family_index].clone(); + if family.gamma.is_some() || family.terms.len() != 1 { + return Err(EmitError::new(format!( + "{stage} relation output function family @{family_symbol} must be one ungamified term" + ))); + } + let term = &family.terms[0]; + if term.gamma_power_offset != 0 + || term.function != RelationOutputFunctionKind::BooleanZero + || term.factors.len() != 1 + { + return Err(EmitError::new(format!( + "{stage} relation output function family @{family_symbol} has unsupported boolean-zero shape" + ))); + } + + let prefix = relation_output_family_prefix(&family.symbol); + let square = format!("{prefix}.boolean_zero.square"); + let boolean_zero = format!("{prefix}.boolean_zero"); + let claim_expr = format!("{prefix}.claim_expr"); + let rows = vec![ + relation_output_field_expr( + square.clone(), + "field.product", + vec![term.eval.clone(), term.eval.clone()], + ), + relation_output_field_expr( + boolean_zero.clone(), + "field.sub", + vec![square, term.eval.clone()], + ), + relation_output_field_expr( + claim_expr.clone(), + "field.product", + vec![boolean_zero, term.factors[0].clone()], + ), + ]; + claim.expected_output = claim_expr; + let _removed_family = relation_output_function_families.remove(family_index); + Ok(rows) +} + +pub fn lower_eval_family_output( + stage: &str, + relation: &str, + relation_output_eval_families: &mut Vec, + relation_output_asts: &mut [RelationOutputAst], +) -> Result, EmitError> { + let Some(claim) = relation_output_asts + .iter_mut() + .find(|claim| claim.relation == relation) + else { + return Ok(Vec::new()); + }; + let family_symbol = claim.expected_output.clone(); + let family_index = relation_output_eval_families + .iter() + .position(|family| family.symbol == family_symbol) + .ok_or_else(|| { + EmitError::new(format!( + "{stage} relation output for @{relation} references missing eval family @{family_symbol}" + )) + })?; + let family = relation_output_eval_families[family_index].clone(); + for term in &family.item_terms { + verify_count( + "relation output eval family item factors", + &family.symbol, + family.evals.len(), + term.factors.len(), + )?; + } + + let prefix = relation_output_family_prefix(&family.symbol); + let mut rows = Vec::new(); + let mut term_symbols = Vec::new(); + let mut gamma_powers = BTreeMap::new(); + let mut term_index = 0usize; + for (eval_index, eval_symbol) in family.evals.iter().enumerate() { + let gamma_base = eval_index * family.power_stride; + for &offset in &family.value_term_offsets { + let gamma_power_offset = gamma_base + offset; + let operands = eval_family_term_operands( + eval_symbol, + gamma_power_offset, + None, + &family.gamma, + prefix, + &mut gamma_powers, + &mut rows, + ); + push_eval_family_term(prefix, term_index, operands, &mut term_symbols, &mut rows); + term_index += 1; + } + for term in &family.shared_terms { + let gamma_power_offset = gamma_base + term.gamma_power_offset; + let operands = eval_family_term_operands( + eval_symbol, + gamma_power_offset, + Some(&term.factor), + &family.gamma, + prefix, + &mut gamma_powers, + &mut rows, + ); + push_eval_family_term(prefix, term_index, operands, &mut term_symbols, &mut rows); + term_index += 1; + } + for term in &family.item_terms { + let gamma_power_offset = gamma_base + term.gamma_power_offset; + let operands = eval_family_term_operands( + eval_symbol, + gamma_power_offset, + Some(&term.factors[eval_index]), + &family.gamma, + prefix, + &mut gamma_powers, + &mut rows, + ); + push_eval_family_term(prefix, term_index, operands, &mut term_symbols, &mut rows); + term_index += 1; + } + } + if term_symbols.is_empty() { + return Err(EmitError::new(format!( + "{stage} relation output eval family @{family_symbol} has no scalar terms" + ))); + } + + let claim_expr = format!("{prefix}.claim_expr"); + rows.push(relation_output_field_expr( + claim_expr.clone(), + "field.sum", + term_symbols, + )); + claim.expected_output = claim_expr; + let _removed_family = relation_output_eval_families.remove(family_index); + Ok(rows) +} + +fn eval_family_term_operands( + eval_symbol: &str, + gamma_power_offset: usize, + factor: Option<&String>, + gamma: &str, + prefix: &str, + gamma_powers: &mut BTreeMap, + rows: &mut Vec, +) -> Vec { + let mut operands = vec![eval_symbol.to_owned()]; + if gamma_power_offset > 0 { + operands.push(eval_family_gamma_power( + gamma_power_offset, + gamma, + prefix, + gamma_powers, + rows, + )); + } + if let Some(factor) = factor { + operands.push(factor.clone()); + } + operands +} + +fn eval_family_gamma_power( + exponent: usize, + gamma: &str, + prefix: &str, + gamma_powers: &mut BTreeMap, + rows: &mut Vec, +) -> String { + if let Some(symbol) = gamma_powers.get(&exponent) { + return symbol.clone(); + } + let symbol = format!("{prefix}.gamma_pow_{exponent}"); + rows.push(relation_output_field_expr( + symbol.clone(), + format!("field.pow:{exponent}"), + vec![gamma.to_owned()], + )); + let _old = gamma_powers.insert(exponent, symbol.clone()); + symbol +} + +fn push_eval_family_term( + prefix: &str, + term_index: usize, + operands: Vec, + term_symbols: &mut Vec, + rows: &mut Vec, +) { + let symbol = format!("{prefix}.term{term_index}"); + rows.push(relation_output_field_expr( + symbol.clone(), + "field.product", + operands, + )); + term_symbols.push(symbol); +} + +fn relation_output_family_prefix(symbol: &str) -> &str { + symbol.strip_suffix(".family").unwrap_or(symbol) +} + +fn relation_output_field_expr( + symbol: String, + formula: impl Into, + operands: Vec, +) -> RelationOutputFieldExprPlan { + RelationOutputFieldExprPlan { + symbol, + formula: formula.into(), + operands, + } +} + pub trait FieldExprDependencies { fn symbol(&self) -> &str; fn operands(&self) -> &[String]; diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 69d3629d30..e2f0f56a34 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1556,7 +1556,7 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(prover_program.relation_output_values.len(), 8); assert!(prover_program.relation_outputs.is_empty()); assert_eq!(verifier_program.relation_output_values.len(), 8); - assert_eq!(verifier_program.relation_output_eval_families.len(), 1); + assert!(verifier_program.relation_output_eval_families.is_empty()); assert_eq!(verifier_program.relation_output_product_families.len(), 2); assert_eq!(verifier_program.relation_output_function_families.len(), 1); assert_eq!(verifier_program.relation_outputs.len(), 6); @@ -1666,46 +1666,35 @@ fn stage6_rust_targets_extract_and_compile() { vec!["stage6.instruction_ra_virtual.output.eq.Cycle".to_owned()] ); } - let inc_family = &verifier_program.relation_output_eval_families[0]; - assert_eq!( - inc_family.symbol, - "stage6.inc_claim_reduction.output.family" - ); - assert_eq!(inc_family.gamma, "stage6.inc_claim_reduction.gamma"); - assert_eq!( - inc_family.evals, - vec![ - "stage6.inc_claim_reduction.eval.RamInc".to_owned(), - "stage6.inc_claim_reduction.eval.RdInc".to_owned() - ] - ); - assert_eq!(inc_family.power_stride, 2); - assert!(inc_family.value_term_offsets.is_empty()); - assert!(inc_family.shared_terms.is_empty()); - assert_eq!(inc_family.item_terms.len(), 2); - assert_eq!(inc_family.item_terms[0].gamma_power_offset, 0); - assert_eq!( - inc_family.item_terms[0].factors, - vec![ - "stage6.inc_claim_reduction.output.eq.RamIncStage2".to_owned(), - "stage6.inc_claim_reduction.output.eq.RdIncStage4".to_owned() - ] - ); - assert_eq!(inc_family.item_terms[1].gamma_power_offset, 1); + let inc_expr_symbols = verifier_program + .field_exprs + .iter() + .filter(|expr| { + expr.symbol + .starts_with("stage6.inc_claim_reduction.output.") + }) + .map(|expr| expr.symbol.as_str()) + .collect::>(); assert_eq!( - inc_family.item_terms[1].factors, + inc_expr_symbols, vec![ - "stage6.inc_claim_reduction.output.eq.RamIncStage4".to_owned(), - "stage6.inc_claim_reduction.output.eq.RdIncStage5".to_owned() + "stage6.inc_claim_reduction.output.term0", + "stage6.inc_claim_reduction.output.gamma_pow_1", + "stage6.inc_claim_reduction.output.term1", + "stage6.inc_claim_reduction.output.gamma_pow_2", + "stage6.inc_claim_reduction.output.term2", + "stage6.inc_claim_reduction.output.gamma_pow_3", + "stage6.inc_claim_reduction.output.term3", + "stage6.inc_claim_reduction.output.claim_expr" ] ); let inc_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.inc_claim_reduction.output.family") + .filter(|claim| claim.expected_output == "stage6.inc_claim_reduction.output.claim_expr") .collect::>(); assert_eq!(inc_claims.len(), 1); - assert_eq!(inc_claims[0].eval_families, vec![inc_family.clone()]); + assert!(inc_claims[0].eval_families.is_empty()); assert!(inc_claims[0].product_families.is_empty()); assert!(inc_claims[0].function_families.is_empty()); let booleanity_claims = verifier_program @@ -1911,7 +1900,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES")); - assert!(verifier_source + assert!(!verifier_source .source .contains("STAGE6_RELATION_OUTPUT_4_FAMILIES")); assert!(verifier_source @@ -1950,6 +1939,19 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("stage6.inc_claim_reduction.output.eq.RdIncStage5")); + assert!(!verifier_source + .source + .contains("stage6.inc_claim_reduction.output.family")); + assert!(verifier_source + .source + .contains("stage6.inc_claim_reduction.output.claim_expr")); + assert!(verifier_source + .source + .contains("stage6.inc_claim_reduction.output.gamma_pow_3")); + assert!(verifier_source.source.contains("Stage6FieldExprKind::Sum")); + assert!(verifier_source + .source + .contains("Stage6FieldExprKind::Product")); assert!(!verifier_source .source .contains("stage6.hamming_booleanity.output.square.HammingWeight")); @@ -1983,12 +1985,9 @@ fn stage6_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("stage6.instruction_ra_virtual.output.claim_expr")); - assert!(!verifier_source - .source - .contains("stage6.inc_claim_reduction.output.term.RamInc")); - assert!(!verifier_source + assert!(verifier_source .source - .contains("stage6.inc_claim_reduction.output.gamma2")); + .contains("stage6.inc_claim_reduction.output.term0")); assert!(verifier_source .source .contains("stage6.bytecode_read_raf.eval.BytecodeRa_0")); diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 15ba744804..94b2418ba1 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -294,7 +294,8 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term3.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), - stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero.square", Stage6FieldExprKind::Mul, &["stage6.hamming_booleanity.eval.HammingWeight", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.hamming_booleanity.output.boolean_zero.square", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Mul, &["stage6.hamming_booleanity.output.boolean_zero", "stage6.hamming_booleanity.output.eq.LookupOutput"]), + stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.eval.HammingWeight", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.hamming_booleanity.output.boolean_zero.square", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.output.boolean_zero", "stage6.hamming_booleanity.output.eq.LookupOutput"]), stage6_field_expr("stage6.inc_claim_reduction.output.term0", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.eq.RamIncStage2"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term1", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.gamma_pow_1", "stage6.inc_claim_reduction.output.eq.RamIncStage4"]), + stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term2", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term3", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_3", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.inc_claim_reduction.output.term0", "stage6.inc_claim_reduction.output.term1", "stage6.inc_claim_reduction.output.term2", "stage6.inc_claim_reduction.output.term3"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -710,18 +711,6 @@ pub const STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES: &[bolt_verifier_runtime::Re bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: Some("stage6.instruction_ra_virtual.gamma"), terms: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILY_0_TERMS }, ]; -pub const STAGE6_RELATION_OUTPUT_4_FAMILY_0_EVALS: &[&str] = &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.eval.RdInc"]; -pub const STAGE6_RELATION_OUTPUT_4_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan] = &[ - -]; -pub const STAGE6_RELATION_OUTPUT_4_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan] = &[ - bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan { gamma_power_offset: 0, factors: &["stage6.inc_claim_reduction.output.eq.RamIncStage2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"] }, - bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan { gamma_power_offset: 1, factors: &["stage6.inc_claim_reduction.output.eq.RamIncStage4", "stage6.inc_claim_reduction.output.eq.RdIncStage5"] }, -]; -pub const STAGE6_RELATION_OUTPUT_4_FAMILIES: &[bolt_verifier_runtime::RelationOutputEvalFamilyPlan] = &[ - bolt_verifier_runtime::RelationOutputEvalFamilyPlan { symbol: "stage6.inc_claim_reduction.output.family", gamma: "stage6.inc_claim_reduction.gamma", evals: STAGE6_RELATION_OUTPUT_4_FAMILY_0_EVALS, power_stride: 2, value_term_offsets: &[], shared_terms: STAGE6_RELATION_OUTPUT_4_FAMILY_0_SHARED_TERMS, item_terms: STAGE6_RELATION_OUTPUT_4_FAMILY_0_ITEM_TERMS }, -]; - pub const STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.bytecode_read_raf.output.contribution"], eval_families: &["stage6.bytecode_read_raf.eval.BytecodeRa"], factors: &[] }, ]; @@ -735,7 +724,7 @@ pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.family" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: STAGE6_RELATION_OUTPUT_4_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, ]; From f997c137a9fc2530dd5a4ae3147624e425640c5e Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 20:04:43 -0600 Subject: [PATCH 101/171] refactor(bolt): lower product outputs scalar --- .../src/protocols/jolt/emit/rust/stage6.rs | 22 ++++ .../jolt/verifier_relation_outputs.rs | 98 +++++++++++++- crates/bolt/tests/commitment_ir.rs | 122 ++++++++++-------- crates/jolt-verifier/src/stages/stage6.rs | 29 +---- 4 files changed, 189 insertions(+), 82 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 840058cad7..4e6576b594 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -678,6 +678,7 @@ impl Stage6CpuProgram { lower_stage6_relation_outputs( &mut field_exprs, &mut relation_output_eval_families, + &mut relation_output_product_families, &mut relation_output_function_families, &mut relation_output_asts, )?; @@ -2766,6 +2767,7 @@ fn stage6_trace_rounds( fn lower_stage6_relation_outputs( field_exprs: &mut Vec, relation_output_eval_families: &mut Vec, + relation_output_product_families: &mut Vec, relation_output_function_families: &mut Vec, relation_output_asts: &mut [Stage6RelationOutputAst], ) -> Result<(), EmitError> { @@ -2789,6 +2791,26 @@ fn lower_stage6_relation_outputs( .into_iter() .map(stage6_relation_output_expr), ); + field_exprs.extend( + verifier_relation_outputs::lower_product_family_output( + "stage6", + "jolt.stage6.ram_ra_virtual", + relation_output_product_families, + relation_output_asts, + )? + .into_iter() + .map(stage6_relation_output_expr), + ); + field_exprs.extend( + verifier_relation_outputs::lower_product_family_output( + "stage6", + "jolt.stage6.instruction_ra_virtual", + relation_output_product_families, + relation_output_asts, + )? + .into_iter() + .map(stage6_relation_output_expr), + ); Ok(()) } diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 2f7e531899..cacd3e8bf0 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -647,7 +647,13 @@ pub fn lower_eval_family_output( &mut gamma_powers, &mut rows, ); - push_eval_family_term(prefix, term_index, operands, &mut term_symbols, &mut rows); + push_relation_output_product_term( + prefix, + term_index, + operands, + &mut term_symbols, + &mut rows, + ); term_index += 1; } for term in &family.shared_terms { @@ -661,7 +667,13 @@ pub fn lower_eval_family_output( &mut gamma_powers, &mut rows, ); - push_eval_family_term(prefix, term_index, operands, &mut term_symbols, &mut rows); + push_relation_output_product_term( + prefix, + term_index, + operands, + &mut term_symbols, + &mut rows, + ); term_index += 1; } for term in &family.item_terms { @@ -675,7 +687,13 @@ pub fn lower_eval_family_output( &mut gamma_powers, &mut rows, ); - push_eval_family_term(prefix, term_index, operands, &mut term_symbols, &mut rows); + push_relation_output_product_term( + prefix, + term_index, + operands, + &mut term_symbols, + &mut rows, + ); term_index += 1; } } @@ -696,6 +714,78 @@ pub fn lower_eval_family_output( Ok(rows) } +pub fn lower_product_family_output( + stage: &str, + relation: &str, + relation_output_product_families: &mut Vec, + relation_output_asts: &mut [RelationOutputAst], +) -> Result, EmitError> { + let Some(claim) = relation_output_asts + .iter_mut() + .find(|claim| claim.relation == relation) + else { + return Ok(Vec::new()); + }; + let family_symbol = claim.expected_output.clone(); + let family_index = relation_output_product_families + .iter() + .position(|family| family.symbol == family_symbol) + .ok_or_else(|| { + EmitError::new(format!( + "{stage} relation output for @{relation} references missing product family @{family_symbol}" + )) + })?; + let family = relation_output_product_families[family_index].clone(); + + let prefix = relation_output_family_prefix(&family.symbol); + let mut rows = Vec::new(); + let mut term_symbols = Vec::with_capacity(family.terms.len()); + let mut gamma_powers = BTreeMap::new(); + for (term_index, term) in family.terms.iter().enumerate() { + if !term.eval_families.is_empty() { + return Err(EmitError::new(format!( + "{stage} relation output product family @{family_symbol} requires field-vector product support" + ))); + } + let mut operands = Vec::new(); + if let Some(gamma) = &family.gamma { + if term.gamma_power_offset > 0 { + operands.push(eval_family_gamma_power( + term.gamma_power_offset, + gamma, + prefix, + &mut gamma_powers, + &mut rows, + )); + } + } + operands.extend(term.evals.iter().cloned()); + operands.extend(term.factors.iter().cloned()); + if operands.is_empty() { + return Err(EmitError::new(format!( + "{stage} relation output product family @{family_symbol} has an empty scalar term" + ))); + } + push_relation_output_product_term( + prefix, + term_index, + operands, + &mut term_symbols, + &mut rows, + ); + } + + let claim_expr = format!("{prefix}.claim_expr"); + rows.push(relation_output_field_expr( + claim_expr.clone(), + "field.sum", + term_symbols, + )); + claim.expected_output = claim_expr; + let _removed_family = relation_output_product_families.remove(family_index); + Ok(rows) +} + fn eval_family_term_operands( eval_symbol: &str, gamma_power_offset: usize, @@ -741,7 +831,7 @@ fn eval_family_gamma_power( symbol } -fn push_eval_family_term( +fn push_relation_output_product_term( prefix: &str, term_index: usize, operands: Vec, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index e2f0f56a34..e56149d5c4 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1557,7 +1557,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(prover_program.relation_outputs.is_empty()); assert_eq!(verifier_program.relation_output_values.len(), 8); assert!(verifier_program.relation_output_eval_families.is_empty()); - assert_eq!(verifier_program.relation_output_product_families.len(), 2); + assert!(verifier_program.relation_output_product_families.is_empty()); assert_eq!(verifier_program.relation_output_function_families.len(), 1); assert_eq!(verifier_program.relation_outputs.len(), 6); let total_booleanity_ra = params.instruction_d + params.bytecode_d + params.ram_d; @@ -1614,46 +1614,64 @@ fn stage6_rust_targets_extract_and_compile() { "stage6.hamming_booleanity.output.claim_expr" ] ); - let ram_product_families = verifier_program + assert!(verifier_program .relation_output_product_families .iter() - .filter(|family| family.symbol == "stage6.ram_ra_virtual.output.family") - .collect::>(); - assert_eq!(ram_product_families.len(), 1); - let ram_product_family = ram_product_families[0]; - assert_eq!(ram_product_family.gamma, None); - assert_eq!(ram_product_family.terms.len(), 1); - assert_eq!(ram_product_family.terms[0].gamma_power_offset, 0); - assert_eq!( - ram_product_family.terms[0].evals, - (0..params.ram_d) - .map(|index| format!("stage6.ram_ra_virtual.eval.RamRa_{index}")) - .collect::>() - ); - assert_eq!( - ram_product_family.terms[0].factors, - vec!["stage6.ram_ra_virtual.output.eq.Cycle".to_owned()] - ); - let instruction_product_families = verifier_program + .all(|family| family.symbol != "stage6.ram_ra_virtual.output.family")); + assert!(verifier_program .relation_output_product_families .iter() - .filter(|family| family.symbol == "stage6.instruction_ra_virtual.output.family") + .all(|family| family.symbol != "stage6.instruction_ra_virtual.output.family")); + let ram_expr_symbols = verifier_program + .field_exprs + .iter() + .filter(|expr| expr.symbol.starts_with("stage6.ram_ra_virtual.output.")) + .map(|expr| expr.symbol.as_str()) .collect::>(); - assert_eq!(instruction_product_families.len(), 1); - let instruction_product_family = instruction_product_families[0]; - assert_eq!( - instruction_product_family.gamma, - Some("stage6.instruction_ra_virtual.gamma".to_owned()) - ); assert_eq!( - instruction_product_family.terms.len(), - params.instruction_ra_virtual_d + ram_expr_symbols, + vec![ + "stage6.ram_ra_virtual.output.term0", + "stage6.ram_ra_virtual.output.claim_expr" + ] ); let committed_per_virtual = params.instruction_d / params.instruction_ra_virtual_d; - for (virtual_index, term) in instruction_product_family.terms.iter().enumerate() { - assert_eq!(term.gamma_power_offset, virtual_index); + let instruction_exprs = verifier_program + .field_exprs + .iter() + .filter(|expr| { + expr.symbol + .starts_with("stage6.instruction_ra_virtual.output.") + }) + .collect::>(); + assert!(instruction_exprs + .iter() + .any(|expr| expr.symbol == "stage6.instruction_ra_virtual.output.claim_expr")); + assert!(instruction_exprs + .iter() + .any(|expr| expr.symbol == "stage6.instruction_ra_virtual.output.gamma_pow_7")); + for virtual_index in 0..params.instruction_ra_virtual_d { + let term = instruction_exprs + .iter() + .find(|expr| { + expr.symbol == format!("stage6.instruction_ra_virtual.output.term{virtual_index}") + }) + .expect("instruction RA virtual output term"); + if virtual_index == 0 { + assert!(!term + .operands + .contains(&"stage6.instruction_ra_virtual.output.gamma_pow_0".to_owned())); + } else { + assert!(term.operands.contains(&format!( + "stage6.instruction_ra_virtual.output.gamma_pow_{virtual_index}" + ))); + } assert_eq!( - term.evals, + term.operands + .iter() + .filter(|operand| operand.contains(".eval.InstructionRa_")) + .cloned() + .collect::>(), (0..committed_per_virtual) .map(|chunk_index| { let index = virtual_index * committed_per_virtual + chunk_index; @@ -1661,10 +1679,9 @@ fn stage6_rust_targets_extract_and_compile() { }) .collect::>() ); - assert_eq!( - term.factors, - vec!["stage6.instruction_ra_virtual.output.eq.Cycle".to_owned()] - ); + assert!(term + .operands + .contains(&"stage6.instruction_ra_virtual.output.eq.Cycle".to_owned())); } let inc_expr_symbols = verifier_program .field_exprs @@ -1726,26 +1743,20 @@ fn stage6_rust_targets_extract_and_compile() { let ram_ra_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.ram_ra_virtual.output.family") + .filter(|claim| claim.expected_output == "stage6.ram_ra_virtual.output.claim_expr") .collect::>(); assert_eq!(ram_ra_claims.len(), 1); assert!(ram_ra_claims[0].eval_families.is_empty()); - assert_eq!( - ram_ra_claims[0].product_families, - vec![ram_product_family.clone()] - ); + assert!(ram_ra_claims[0].product_families.is_empty()); assert!(ram_ra_claims[0].function_families.is_empty()); let instruction_ra_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.instruction_ra_virtual.output.family") + .filter(|claim| claim.expected_output == "stage6.instruction_ra_virtual.output.claim_expr") .collect::>(); assert_eq!(instruction_ra_claims.len(), 1); assert!(instruction_ra_claims[0].eval_families.is_empty()); - assert_eq!( - instruction_ra_claims[0].product_families, - vec![instruction_product_family.clone()] - ); + assert!(instruction_ra_claims[0].product_families.is_empty()); assert!(instruction_ra_claims[0].function_families.is_empty()); let bytecode_claims = verifier_program .relation_outputs @@ -1906,12 +1917,15 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("RelationOutputProductFamilyPlan")); - assert!(verifier_source + assert!(!verifier_source .source .contains("STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES")); - assert!(verifier_source + assert!(!verifier_source .source .contains("STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES")); + assert!(verifier_source + .source + .contains("STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES")); assert!(verifier_source .source .contains("stage6.booleanity.output.family")); @@ -1930,10 +1944,10 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("stage6.hamming_booleanity.output.boolean_zero")); - assert!(verifier_source + assert!(!verifier_source .source .contains("stage6.ram_ra_virtual.output.family")); - assert!(verifier_source + assert!(!verifier_source .source .contains("stage6.instruction_ra_virtual.output.family")); assert!(verifier_source @@ -1964,7 +1978,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("stage6.ram_ra_virtual.output.product.RamRa")); - assert!(!verifier_source + assert!(verifier_source .source .contains("stage6.ram_ra_virtual.output.claim_expr")); assert!(!verifier_source @@ -1979,10 +1993,10 @@ fn stage6_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("stage6.instruction_ra_virtual.output.term.InstructionRa_")); - assert!(!verifier_source + assert!(verifier_source .source - .contains("stage6.instruction_ra_virtual.output.gamma_pow_")); - assert!(!verifier_source + .contains("stage6.instruction_ra_virtual.output.gamma_pow_7")); + assert!(verifier_source .source .contains("stage6.instruction_ra_virtual.output.claim_expr")); assert!(verifier_source diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 94b2418ba1..8f886cebc5 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -295,7 +295,9 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.eval.HammingWeight", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.hamming_booleanity.output.boolean_zero.square", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.output.boolean_zero", "stage6.hamming_booleanity.output.eq.LookupOutput"]), stage6_field_expr("stage6.inc_claim_reduction.output.term0", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.eq.RamIncStage2"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term1", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.gamma_pow_1", "stage6.inc_claim_reduction.output.eq.RamIncStage4"]), - stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term2", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term3", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_3", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.inc_claim_reduction.output.term0", "stage6.inc_claim_reduction.output.term1", "stage6.inc_claim_reduction.output.term2", "stage6.inc_claim_reduction.output.term3"]), + stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term2", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term3", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_3", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.inc_claim_reduction.output.term0", "stage6.inc_claim_reduction.output.term1", "stage6.inc_claim_reduction.output.term2", "stage6.inc_claim_reduction.output.term3"]), stage6_field_expr("stage6.ram_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3", "stage6.ram_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.ram_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.ram_ra_virtual.output.term0"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.instruction_ra_virtual.output.eq.Cycle"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term1", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_1", "stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term2", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_2", "stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term3", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term4", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.instruction_ra_virtual.output.eq.Cycle"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term5", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -690,27 +692,6 @@ pub const STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::R bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { symbol: "stage6.booleanity.output.family", gamma: Some("stage6.booleanity.gamma"), terms: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILY_0_TERMS }, ]; -pub const STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3"], eval_families: &[], factors: &["stage6.ram_ra_virtual.output.eq.Cycle"] }, -]; -pub const STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::RelationOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage6.ram_ra_virtual.output.family", gamma: None, terms: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS }, -]; - -pub const STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 1, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 2, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 3, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 4, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 5, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 6, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 7, evals: &["stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31"], eval_families: &[], factors: &["stage6.instruction_ra_virtual.output.eq.Cycle"] }, -]; -pub const STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES: &[bolt_verifier_runtime::RelationOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage6.instruction_ra_virtual.output.family", gamma: Some("stage6.instruction_ra_virtual.gamma"), terms: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILY_0_TERMS }, -]; - pub const STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.bytecode_read_raf.output.contribution"], eval_families: &["stage6.bytecode_read_raf.eval.BytecodeRa"], factors: &[] }, ]; @@ -722,8 +703,8 @@ pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_r pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES, function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.family" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, ]; From 134cf4702181d3a04c9a89cb6fbaa72054b2cc04 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 20:19:41 -0600 Subject: [PATCH 102/171] refactor(bolt): lower bytecode vector output --- crates/bolt-verifier-runtime/src/lib.rs | 93 ++++++++++++++++--- .../src/protocols/jolt/emit/rust/stage6.rs | 54 +++++++++-- .../src/protocols/jolt/rust_target_plan.rs | 14 +++ .../jolt/stage6_bytecode_read_raf_plan.rs | 75 +++++++++------ .../bolt/src/protocols/jolt/verifier_plan.rs | 15 ++- .../src/protocols/jolt/verifier_values.rs | 32 ++++++- crates/bolt/tests/commitment_ir.rs | 45 ++++++--- crates/jolt-verifier/src/stages/stage6.rs | 12 +-- 8 files changed, 262 insertions(+), 78 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index c9a6bdeab2..16026ac9b6 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -246,6 +246,8 @@ pub enum FieldExprKind { Mul, Sum, Product, + FieldVectorSum, + FieldVectorProduct, Neg, Pow(usize), LagrangeBasisEval(i64, usize, usize), @@ -1136,10 +1138,19 @@ impl ValueStore { } fn try_expr_operands(&self, expr: &FieldExprPlan) -> Option> { - expr.operands - .iter() - .map(|operand| self.try_scalar(operand)) - .collect() + match expr.kind { + FieldExprKind::FieldVectorSum | FieldExprKind::FieldVectorProduct => { + let [symbol] = expr.operands else { + return Some(Vec::new()); + }; + self.try_field_vector(symbol).map(|values| values.to_vec()) + } + _ => expr + .operands + .iter() + .map(|operand| self.try_scalar(operand)) + .collect(), + } } fn try_concat_point(&self, concat: &PointConcatPlan) -> Option> { @@ -1681,12 +1692,7 @@ fn evaluate_available_field_exprs_with_scratch( if scratch.scalar_or(store, expr.symbol).is_some() { continue; } - let Some(operands) = expr - .operands - .iter() - .map(|operand| scratch.scalar_or(store, operand)) - .collect::>>() - else { + let Some(operands) = relation_output_expr_operands(expr, store, scratch) else { continue; }; scratch.insert(expr.symbol, evaluate_field_expr(expr, &operands)?); @@ -1698,6 +1704,26 @@ fn evaluate_available_field_exprs_with_scratch( } } +fn relation_output_expr_operands( + expr: &FieldExprPlan, + store: &ValueStore, + scratch: &ScratchScalars, +) -> Option> { + match expr.kind { + FieldExprKind::FieldVectorSum | FieldExprKind::FieldVectorProduct => { + let [symbol] = expr.operands else { + return Some(Vec::new()); + }; + store.try_field_vector(symbol).map(|values| values.to_vec()) + } + _ => expr + .operands + .iter() + .map(|operand| scratch.scalar_or(store, operand)) + .collect(), + } +} + pub fn single_operand( symbol: &'static str, operands: &[F], @@ -1770,6 +1796,20 @@ pub fn evaluate_field_expr( .copied() .fold(F::from_u64(1), |acc, operand| acc * operand)) } + FieldExprKind::FieldVectorSum => { + require_min_operand_count(expr.symbol, 1, operands.len())?; + Ok(operands + .iter() + .copied() + .fold(F::from_u64(0), |acc, operand| acc + operand)) + } + FieldExprKind::FieldVectorProduct => { + require_min_operand_count(expr.symbol, 1, operands.len())?; + Ok(operands + .iter() + .copied() + .fold(F::from_u64(1), |acc, operand| acc * operand)) + } FieldExprKind::Neg => { require_operand_count(expr.symbol, 1, operands.len())?; Ok(-operands[0]) @@ -1923,9 +1963,9 @@ pub fn reverse_slice(values: &[Fr]) -> Vec { )] mod tests { use super::{ - evaluate_relation_output_product_family, Fr, NamedEvalFamilyPlan, - RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, RuntimePlanError, - ScratchScalars, ValueStore, + evaluate_field_expr, evaluate_relation_output_product_family, FieldExprKind, FieldExprPlan, + Fr, NamedEvalFamilyPlan, RelationOutputProductFamilyPlan, + RelationOutputProductFamilyTermPlan, RuntimePlanError, ScratchScalars, ValueStore, }; #[test] @@ -1965,6 +2005,33 @@ mod tests { ); } + #[test] + fn value_store_evaluates_field_vector_exprs() { + let mut store = ValueStore::default(); + store.insert_field_vector("family.ab", vec![Fr::from_u64(2), Fr::from_u64(3)]); + + store + .evaluate_available_field_exprs( + &[ + FieldExprPlan { + symbol: "family.ab.product", + kind: FieldExprKind::FieldVectorProduct, + operands: &["family.ab"], + }, + FieldExprPlan { + symbol: "family.ab.sum", + kind: FieldExprKind::FieldVectorSum, + operands: &["family.ab"], + }, + ], + evaluate_field_expr, + ) + .unwrap(); + + assert_eq!(store.try_scalar("family.ab.product"), Some(Fr::from_u64(6))); + assert_eq!(store.try_scalar("family.ab.sum"), Some(Fr::from_u64(5))); + } + #[test] fn product_family_multiplies_field_vector_terms() { let mut store = ValueStore::default(); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 4e6576b594..d64195710b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -11,6 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::rust_target_plan::FieldExprKind; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, stage6_bytecode_read_raf_relation_output_plan, STAGE6_BYTECODE_RA_EVAL_FAMILY, @@ -701,9 +702,15 @@ impl Stage6CpuProgram { &indexed_eval_families, STAGE6_BYTECODE_RA_EVAL_FAMILY, )?; - relation_outputs.push(stage6_bytecode_read_raf_relation_output_plan( - bytecode_ra_evals, - )); + let bytecode_output_plan = + stage6_bytecode_read_raf_relation_output_plan(bytecode_ra_evals); + field_exprs.extend( + bytecode_output_plan + .field_exprs + .into_iter() + .map(stage6_relation_output_expr), + ); + relation_outputs.push(bytecode_output_plan.claim); } let mut program = Self { @@ -809,6 +816,11 @@ impl Stage6CpuProgram { } else { self.cpu_field_value_sources() }; + let field_vector_values = if self.role == Role::Verifier { + Some(self.verifier_plan()?.field_vector_value_sources()) + } else { + None + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -816,12 +828,36 @@ impl Stage6CpuProgram { expr.operand_names.len(), expr.operands.len(), )?; - for operand in &expr.operands { - if !field_values.contains(operand) { - return Err(EmitError::new(format!( - "field expr @{} references missing field value @{operand}", - expr.symbol - ))); + let kind = FieldExprKind::from_cpu_attr(&expr.formula) + .map_err(|error| EmitError::new(error.to_string()))?; + match kind { + FieldExprKind::FieldVectorSum | FieldExprKind::FieldVectorProduct => { + verify_count( + "field vector expr operands", + &expr.symbol, + 1, + expr.operands.len(), + )?; + let operand = &expr.operands[0]; + if !field_vector_values + .as_ref() + .is_some_and(|values| values.contains(operand)) + { + return Err(EmitError::new(format!( + "field vector expr @{} references missing field vector @{operand}", + expr.symbol + ))); + } + } + _ => { + for operand in &expr.operands { + if !field_values.contains(operand) { + return Err(EmitError::new(format!( + "field expr @{} references missing field value @{operand}", + expr.symbol + ))); + } + } } } } diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index 821ad5b616..92a05e9944 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -256,6 +256,8 @@ pub(crate) enum FieldExprKind { Mul, Sum, Product, + FieldVectorSum, + FieldVectorProduct, Neg, Pow(usize), LagrangeBasisEval { @@ -274,6 +276,8 @@ impl FieldExprKind { "field.mul" => Ok(Self::Mul), "field.sum" => Ok(Self::Sum), "field.product" => Ok(Self::Product), + "field_vector.sum" => Ok(Self::FieldVectorSum), + "field_vector.product" => Ok(Self::FieldVectorProduct), "field.neg" => Ok(Self::Neg), value if value.starts_with("field.pow:") => parse_pow(value), value if value.starts_with("poly.lagrange_basis_eval:") => parse_lagrange(value), @@ -292,6 +296,8 @@ impl FieldExprKind { Self::Mul => "Mul".to_owned(), Self::Sum => "Sum".to_owned(), Self::Product => "Product".to_owned(), + Self::FieldVectorSum => "FieldVectorSum".to_owned(), + Self::FieldVectorProduct => "FieldVectorProduct".to_owned(), Self::Neg => "Neg".to_owned(), Self::Pow(exponent) => format!("Pow({exponent})"), Self::LagrangeBasisEval { @@ -433,6 +439,14 @@ mod tests { FieldExprKind::from_cpu_attr("field.product").ok(), Some(FieldExprKind::Product) ); + assert_eq!( + FieldExprKind::from_cpu_attr("field_vector.sum").ok(), + Some(FieldExprKind::FieldVectorSum) + ); + assert_eq!( + FieldExprKind::from_cpu_attr("field_vector.product").ok(), + Some(FieldExprKind::FieldVectorProduct) + ); assert_eq!( FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:-1:3:2").ok(), Some(FieldExprKind::LagrangeBasisEval { diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 1650dddbff..93bf5df147 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -1,7 +1,7 @@ use crate::emit::rust::{push_format, EmitError}; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_relation_outputs::{ - RelationOutputPlan, RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, + RelationOutputFieldExprPlan, RelationOutputPlan, }; pub(crate) const STAGE6_BYTECODE_RA_EVAL_FAMILY: &str = "stage6.bytecode_read_raf.eval.BytecodeRa"; @@ -338,33 +338,45 @@ pub(crate) fn stage6_bytecode_read_raf_output_contribution_symbol() -> &'static pub(crate) fn stage6_bytecode_read_raf_relation_output_plan( bytecode_ra_evals: &IndexedEvalFamilyPlan, -) -> RelationOutputPlan { +) -> Stage6BytecodeReadRafRelationOutputPlan { STAGE6_BYTECODE_READ_RAF_PLAN.relation_output_plan(bytecode_ra_evals) } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Stage6BytecodeReadRafRelationOutputPlan { + pub(crate) field_exprs: Vec, + pub(crate) claim: RelationOutputPlan, +} + impl BytecodeReadRafPlan { fn relation_output_plan( &self, bytecode_ra_evals: &IndexedEvalFamilyPlan, - ) -> RelationOutputPlan { - let product_family = RelationOutputProductFamilyPlan { - symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf".to_owned(), - gamma: None, - terms: vec![RelationOutputProductFamilyTermPlan { - gamma_power_offset: 0, - evals: vec![self.output_contribution.to_owned()], - eval_families: vec![bytecode_ra_evals.symbol.clone()], - factors: Vec::new(), - }], - }; - RelationOutputPlan { - relation: "jolt.stage6.bytecode_read_raf".to_owned(), - structured_polynomial_evals: Vec::new(), - eval_families: Vec::new(), - product_families: vec![product_family.clone()], - function_families: Vec::new(), - local_scalars: vec![self.output_contribution.to_owned()], - expected_output: product_family.symbol, + ) -> Stage6BytecodeReadRafRelationOutputPlan { + let bytecode_ra_product = "stage6.bytecode_read_raf.output.product.BytecodeRa".to_owned(); + let claim_expr = "stage6.bytecode_read_raf.output.claim_expr".to_owned(); + Stage6BytecodeReadRafRelationOutputPlan { + field_exprs: vec![ + RelationOutputFieldExprPlan { + symbol: bytecode_ra_product.clone(), + formula: "field_vector.product".to_owned(), + operands: vec![bytecode_ra_evals.symbol.clone()], + }, + RelationOutputFieldExprPlan { + symbol: claim_expr.clone(), + formula: "field.product".to_owned(), + operands: vec![self.output_contribution.to_owned(), bytecode_ra_product], + }, + ], + claim: RelationOutputPlan { + relation: "jolt.stage6.bytecode_read_raf".to_owned(), + structured_polynomial_evals: Vec::new(), + eval_families: Vec::new(), + product_families: Vec::new(), + function_families: Vec::new(), + local_scalars: vec![self.output_contribution.to_owned()], + expected_output: claim_expr, + }, } } } @@ -675,28 +687,33 @@ mod tests { #[test] fn stage6_bytecode_relation_output_plan_uses_point_derived_contribution() { let bytecode_ra_evals = bytecode_ra_evals(); - let claim = stage6_bytecode_read_raf_relation_output_plan(&bytecode_ra_evals); + let output_plan = stage6_bytecode_read_raf_relation_output_plan(&bytecode_ra_evals); + let claim = output_plan.claim; assert_eq!(claim.relation, "jolt.stage6.bytecode_read_raf"); assert_eq!( claim.expected_output, - "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" + "stage6.bytecode_read_raf.output.claim_expr" ); assert!(claim.structured_polynomial_evals.is_empty()); assert!(claim.eval_families.is_empty()); - assert_eq!(claim.product_families.len(), 1); - assert_eq!(claim.product_families[0].terms.len(), 1); + assert!(claim.product_families.is_empty()); assert_eq!( claim.local_scalars, vec![stage6_bytecode_read_raf_output_contribution_symbol().to_owned()] ); + assert_eq!(output_plan.field_exprs[0].formula, "field_vector.product"); assert_eq!( - claim.product_families[0].terms[0].evals, - vec![stage6_bytecode_read_raf_output_contribution_symbol().to_owned()] + output_plan.field_exprs[0].operands, + vec![STAGE6_BYTECODE_RA_EVAL_FAMILY.to_owned()] ); + assert_eq!(output_plan.field_exprs[1].formula, "field.product"); assert_eq!( - claim.product_families[0].terms[0].eval_families, - vec![STAGE6_BYTECODE_RA_EVAL_FAMILY.to_owned()] + output_plan.field_exprs[1].operands, + vec![ + stage6_bytecode_read_raf_output_contribution_symbol().to_owned(), + "stage6.bytecode_read_raf.output.product.BytecodeRa".to_owned() + ] ); } diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 5cbd61c2b7..e2c42d45c7 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -12,8 +12,8 @@ use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan, }; use crate::protocols::jolt::verifier_values::{ - VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarSourceKind, - VerifierScalarSourceSet, + VerifierFieldVectorSourceKind, VerifierFieldVectorSourceSet, VerifierPointSourceKind, + VerifierPointSourceSet, VerifierScalarSourceKind, VerifierScalarSourceSet, }; #[derive(Clone, Debug, PartialEq, Eq)] @@ -368,6 +368,17 @@ impl VerifierStagePlan { values } + pub(crate) fn field_vector_value_sources(&self) -> VerifierFieldVectorSourceSet { + let mut values = VerifierFieldVectorSourceSet::default(); + values.extend( + self.indexed_eval_families + .iter() + .map(|family| &family.symbol), + VerifierFieldVectorSourceKind::IndexedEvalFamily, + ); + values + } + pub(crate) fn point_value_sources(&self) -> VerifierPointSourceSet { let mut values = VerifierPointSourceSet::default(); values.extend( diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 887781c1f4..c13826f333 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -1,4 +1,4 @@ -use std::collections::BTreeMap; +use std::collections::{BTreeMap, BTreeSet}; use crate::emit::rust::EmitError; @@ -63,6 +63,36 @@ impl VerifierScalarSourceSet { } } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum VerifierFieldVectorSourceKind { + IndexedEvalFamily, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct VerifierFieldVectorSourceSet { + symbols: BTreeSet, +} + +impl VerifierFieldVectorSourceSet { + pub fn insert(&mut self, symbol: &str, _kind: VerifierFieldVectorSourceKind) { + let _inserted = self.symbols.insert(symbol.to_owned()); + } + + pub fn extend<'a>( + &mut self, + symbols: impl IntoIterator, + kind: VerifierFieldVectorSourceKind, + ) { + for symbol in symbols { + self.insert(symbol, kind); + } + } + + pub fn contains(&self, symbol: &str) -> bool { + self.symbols.contains(symbol) + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum VerifierPointSourceKind { OpeningInput, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index e56149d5c4..904c046ea9 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1761,23 +1761,32 @@ fn stage6_rust_targets_extract_and_compile() { let bytecode_claims = verifier_program .relation_outputs .iter() - .filter(|claim| { - claim.expected_output == "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" - }) + .filter(|claim| claim.expected_output == "stage6.bytecode_read_raf.output.claim_expr") .collect::>(); assert_eq!(bytecode_claims.len(), 1); assert!(bytecode_claims[0].structured_polynomial_evals.is_empty()); assert!(bytecode_claims[0].eval_families.is_empty()); - assert_eq!(bytecode_claims[0].product_families.len(), 1); - assert_eq!( - bytecode_claims[0].product_families[0].terms[0].evals, - vec!["stage6.bytecode_read_raf.output.contribution".to_owned()] - ); - assert_eq!( - bytecode_claims[0].product_families[0].terms[0].eval_families, - vec!["stage6.bytecode_read_raf.eval.BytecodeRa".to_owned()] - ); + assert!(bytecode_claims[0].product_families.is_empty()); assert!(bytecode_claims[0].function_families.is_empty()); + let bytecode_output_exprs = verifier_program + .field_exprs + .iter() + .filter(|expr| expr.symbol.starts_with("stage6.bytecode_read_raf.output.")) + .collect::>(); + assert!(bytecode_output_exprs.iter().any(|expr| { + expr.symbol == "stage6.bytecode_read_raf.output.product.BytecodeRa" + && expr.formula == "field_vector.product" + && expr.operands == vec!["stage6.bytecode_read_raf.eval.BytecodeRa".to_owned()] + })); + assert!(bytecode_output_exprs.iter().any(|expr| { + expr.symbol == "stage6.bytecode_read_raf.output.claim_expr" + && expr.formula == "field.product" + && expr.operands + == vec![ + "stage6.bytecode_read_raf.output.contribution".to_owned(), + "stage6.bytecode_read_raf.output.product.BytecodeRa".to_owned(), + ] + })); assert_eq!(prover_program.point_zeros.len(), 1); assert_eq!( prover_program.point_slices.len(), @@ -1865,9 +1874,15 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("evaluate_stage67_bytecode_read_raf_output_scalars")); - assert!(verifier_source + assert!(!verifier_source .source .contains("stage6.bytecode_read_raf.output.product.BytecodeReadRaf")); + assert!(verifier_source + .source + .contains("stage6.bytecode_read_raf.output.claim_expr")); + assert!(verifier_source + .source + .contains("Stage6FieldExprKind::FieldVectorProduct")); assert!(!verifier_source .source .contains("expected_stage67_bytecode_read_raf")); @@ -1914,7 +1929,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("STAGE6_RELATION_OUTPUT_4_FAMILIES")); - assert!(verifier_source + assert!(!verifier_source .source .contains("RelationOutputProductFamilyPlan")); assert!(!verifier_source @@ -1923,7 +1938,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("STAGE6_RELATION_OUTPUT_3_PRODUCT_FAMILIES")); - assert!(verifier_source + assert!(!verifier_source .source .contains("STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES")); assert!(verifier_source diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 8f886cebc5..fe8f31d987 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -297,7 +297,8 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.eval.HammingWeight", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.hamming_booleanity.output.boolean_zero.square", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.output.boolean_zero", "stage6.hamming_booleanity.output.eq.LookupOutput"]), stage6_field_expr("stage6.inc_claim_reduction.output.term0", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.eq.RamIncStage2"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term1", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.gamma_pow_1", "stage6.inc_claim_reduction.output.eq.RamIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term2", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term3", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_3", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.inc_claim_reduction.output.term0", "stage6.inc_claim_reduction.output.term1", "stage6.inc_claim_reduction.output.term2", "stage6.inc_claim_reduction.output.term3"]), stage6_field_expr("stage6.ram_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3", "stage6.ram_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.ram_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.ram_ra_virtual.output.term0"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term1", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_1", "stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term2", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_2", "stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term3", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term4", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.instruction_ra_virtual.output.eq.Cycle"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term5", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term5", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), stage6_field_expr("stage6.bytecode_read_raf.output.product.BytecodeRa", Stage6FieldExprKind::FieldVectorProduct, &["stage6.bytecode_read_raf.eval.BytecodeRa"]), + stage6_field_expr("stage6.bytecode_read_raf.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.output.product.BytecodeRa"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -692,13 +693,6 @@ pub const STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::R bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { symbol: "stage6.booleanity.output.family", gamma: Some("stage6.booleanity.gamma"), terms: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILY_0_TERMS }, ]; -pub const STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage6.bytecode_read_raf.output.contribution"], eval_families: &["stage6.bytecode_read_raf.eval.BytecodeRa"], factors: &[] }, -]; -pub const STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES: &[bolt_verifier_runtime::RelationOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf", gamma: None, terms: STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILY_0_TERMS }, -]; - pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, @@ -706,7 +700,7 @@ pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], product_families: STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.product.BytecodeReadRaf" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], product_families: &[], function_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { From 7052fff09ef8c2e867175b2bdd9415e88e34385e Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 20:39:33 -0600 Subject: [PATCH 103/171] refactor(bolt): lower booleanity output --- crates/bolt-verifier-runtime/src/lib.rs | 55 ----- .../jolt/emit/rust/relation_outputs.rs | 69 +------ .../src/protocols/jolt/emit/rust/stage5.rs | 6 - .../src/protocols/jolt/emit/rust/stage6.rs | 16 +- .../jolt/stage5_instruction_read_raf_plan.rs | 1 - .../jolt/stage6_bytecode_read_raf_plan.rs | 1 - .../bolt/src/protocols/jolt/verifier_plan.rs | 6 - .../jolt/verifier_relation_outputs.rs | 193 +++++++----------- crates/bolt/tests/commitment_ir.rs | 112 +++++----- crates/jolt-equivalence/src/plan_adapters.rs | 40 ---- crates/jolt-verifier/src/stages/stage3.rs | 6 +- crates/jolt-verifier/src/stages/stage4.rs | 4 +- crates/jolt-verifier/src/stages/stage5.rs | 6 +- crates/jolt-verifier/src/stages/stage6.rs | 86 +++----- crates/jolt-verifier/src/stages/stage7.rs | 2 +- 15 files changed, 180 insertions(+), 423 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 16026ac9b6..033b9c091f 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -426,33 +426,12 @@ pub struct RelationOutputProductFamilyPlan { pub terms: &'static [RelationOutputProductFamilyTermPlan], } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum RelationOutputFunctionKind { - BooleanZero, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct RelationOutputFunctionFamilyTermPlan { - pub gamma_power_offset: usize, - pub function: RelationOutputFunctionKind, - pub eval: &'static str, - pub factors: &'static [&'static str], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct RelationOutputFunctionFamilyPlan { - pub symbol: &'static str, - pub gamma: Option<&'static str>, - pub terms: &'static [RelationOutputFunctionFamilyTermPlan], -} - #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: R, pub structured_polynomial_evals: &'static [StructuredPolynomialEvalRef], pub eval_families: &'static [RelationOutputEvalFamilyPlan], pub product_families: &'static [RelationOutputProductFamilyPlan], - pub function_families: &'static [RelationOutputFunctionFamilyPlan], pub local_scalars: &'static [&'static str], pub expected_output: &'static str, } @@ -1385,10 +1364,6 @@ pub fn evaluate_relation_output( let value = evaluate_relation_output_eval_family(family, store, &scratch)?; scratch.insert(family.symbol, value); } - for family in plan.function_families { - let value = evaluate_relation_output_function_family(family, store, &scratch)?; - scratch.insert(family.symbol, value); - } for family in plan.product_families { let value = evaluate_relation_output_product_family(family, store, &scratch)?; scratch.insert(family.symbol, value); @@ -1556,36 +1531,6 @@ fn evaluate_relation_output_product_family( Ok(result) } -fn evaluate_relation_output_function_family( - family: &RelationOutputFunctionFamilyPlan, - store: &ValueStore, - scratch: &ScratchScalars, -) -> Result { - let gamma = relation_output_family_gamma(family.gamma, store, scratch)?; - let mut result = Fr::from_u64(0); - for term in family.terms { - let eval = scratch - .scalar_or(store, term.eval) - .ok_or(RuntimePlanError::MissingValue { symbol: term.eval })?; - let mut product = pow_field(gamma, term.gamma_power_offset) - * evaluate_relation_output_function(term.function, eval); - for &symbol in term.factors { - let value = scratch - .scalar_or(store, symbol) - .ok_or(RuntimePlanError::MissingValue { symbol })?; - product *= value; - } - result += product; - } - Ok(result) -} - -fn evaluate_relation_output_function(function: RelationOutputFunctionKind, eval: Fr) -> Fr { - match function { - RelationOutputFunctionKind::BooleanZero => eval * eval - eval, - } -} - fn relation_output_family_gamma( gamma: Option<&'static str>, store: &ValueStore, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index a7c66c231f..d0dd6a9a88 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -1,10 +1,9 @@ use crate::emit::rust::{push_format, EmitError}; use crate::ir::Role; use crate::protocols::jolt::verifier_relation_outputs::{ - RelationOutputFunctionKind, RelationOutputPlan, StructuredPolynomialEvalPlan, - StructuredPolynomialEvalRefPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, - StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment, + RelationOutputPlan, StructuredPolynomialEvalPlan, StructuredPolynomialEvalRefPlan, + StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, }; pub fn emit_verifier_relation_output_constants( @@ -28,11 +27,9 @@ pub fn emit_verifier_relation_output_constants( ); let eval_families = emit_eval_family_constants(&mut source, stage_type, index, claim); let product_families = emit_product_family_constants(&mut source, stage_type, index, claim); - let function_families = - emit_function_family_constants(&mut source, stage_type, index, claim)?; let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim); claims.push(format!( - " {stage_type}RelationOutputPlan {{ relation: {}, structured_polynomial_evals: {values}, eval_families: {eval_families}, product_families: {product_families}, function_families: {function_families}, local_scalars: {local_scalars}, expected_output: {} }},", + " {stage_type}RelationOutputPlan {{ relation: {}, structured_polynomial_evals: {values}, eval_families: {eval_families}, product_families: {product_families}, local_scalars: {local_scalars}, expected_output: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, rust_str(&claim.expected_output) )); @@ -227,64 +224,6 @@ fn emit_product_family_constants( families_name } -fn emit_function_family_constants( - source: &mut String, - stage_type: &str, - claim_index: usize, - claim: &RelationOutputPlan, -) -> Result { - if claim.function_families.is_empty() { - return Ok("&[]".to_owned()); - } - let upper_stage = stage_type.to_ascii_uppercase(); - let mut family_rows = Vec::new(); - for (family_index, family) in claim.function_families.iter().enumerate() { - let prefix = - format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_FUNCTION_FAMILY_{family_index}"); - let mut term_rows = Vec::new(); - for (term_index, term) in family.terms.iter().enumerate() { - let factors_name = format!("{prefix}_TERM_{term_index}_FACTORS"); - let factors = emit_str_slice_or_inline(source, &factors_name, &term.factors); - term_rows.push(format!( - " bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan {{ gamma_power_offset: {}, function: {}, eval: {}, factors: {factors} }},", - term.gamma_power_offset, - relation_output_function_kind_expr(term.function), - rust_str(&term.eval) - )); - } - let terms_name = format!("{prefix}_TERMS"); - let terms = term_rows.join("\n"); - push_format( - source, - format_args!( - "pub const {terms_name}: &[bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan] = &[\n{terms}\n];\n" - ), - ); - family_rows.push(format!( - " bolt_verifier_runtime::RelationOutputFunctionFamilyPlan {{ symbol: {}, gamma: {}, terms: {terms_name} }},", - rust_str(&family.symbol), - optional_rust_str(family.gamma.as_deref()), - )); - } - let families_name = format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_FUNCTION_FAMILIES"); - let families = family_rows.join("\n"); - push_format( - source, - format_args!( - "pub const {families_name}: &[bolt_verifier_runtime::RelationOutputFunctionFamilyPlan] = &[\n{families}\n];\n\n" - ), - ); - Ok(families_name) -} - -fn relation_output_function_kind_expr(function: RelationOutputFunctionKind) -> &'static str { - match function { - RelationOutputFunctionKind::BooleanZero => { - "bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero" - } - } -} - fn emit_structured_polynomial_eval_refs_slice_or_inline( source: &mut String, name: &str, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index f3d098d82c..14b0b16e47 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -856,12 +856,6 @@ impl Stage5CpuProgram { .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), - verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, - ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), verifier_values::VerifierScalarSourceKind::FieldExpr, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index d64195710b..e42fb03791 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -934,12 +934,6 @@ impl Stage6CpuProgram { .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), verifier_values::VerifierScalarSourceKind::OutputProductFamily, ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), - verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, - ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), verifier_values::VerifierScalarSourceKind::FieldExpr, @@ -2807,6 +2801,16 @@ fn lower_stage6_relation_outputs( relation_output_function_families: &mut Vec, relation_output_asts: &mut [Stage6RelationOutputAst], ) -> Result<(), EmitError> { + field_exprs.extend( + verifier_relation_outputs::lower_boolean_zero_function_family_output( + "stage6", + "jolt.stage6.booleanity", + relation_output_function_families, + relation_output_asts, + )? + .into_iter() + .map(stage6_relation_output_expr), + ); field_exprs.extend( verifier_relation_outputs::lower_boolean_zero_function_family_output( "stage6", diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index cb574dfa70..ecfbecde2c 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -212,7 +212,6 @@ impl Stage5InstructionReadRafEmitPlan { }], eval_families: Vec::new(), product_families: vec![table_value_family, ra_product_family], - function_families: Vec::new(), local_scalars: self .point_values .iter() diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 93bf5df147..354f1c52f4 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -373,7 +373,6 @@ impl BytecodeReadRafPlan { structured_polynomial_evals: Vec::new(), eval_families: Vec::new(), product_families: Vec::new(), - function_families: Vec::new(), local_scalars: vec![self.output_contribution.to_owned()], expected_output: claim_expr, }, diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index e2c42d45c7..528101db96 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -345,12 +345,6 @@ impl VerifierStagePlan { .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), VerifierScalarSourceKind::OutputProductFamily, ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.function_families.iter().map(|family| &family.symbol)), - VerifierScalarSourceKind::OutputFunctionFamily, - ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), VerifierScalarSourceKind::FieldExpr, diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index cacd3e8bf0..b4d5e30003 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -258,7 +258,6 @@ pub struct RelationOutputPlan { pub structured_polynomial_evals: Vec, pub eval_families: Vec, pub product_families: Vec, - pub function_families: Vec, pub local_scalars: Vec, pub expected_output: String, } @@ -557,42 +556,66 @@ pub fn lower_boolean_zero_function_family_output( )) })?; let family = relation_output_function_families[family_index].clone(); - if family.gamma.is_some() || family.terms.len() != 1 { + if family.terms.is_empty() { return Err(EmitError::new(format!( - "{stage} relation output function family @{family_symbol} must be one ungamified term" - ))); - } - let term = &family.terms[0]; - if term.gamma_power_offset != 0 - || term.function != RelationOutputFunctionKind::BooleanZero - || term.factors.len() != 1 - { - return Err(EmitError::new(format!( - "{stage} relation output function family @{family_symbol} has unsupported boolean-zero shape" + "{stage} relation output function family @{family_symbol} has no scalar terms" ))); } let prefix = relation_output_family_prefix(&family.symbol); - let square = format!("{prefix}.boolean_zero.square"); - let boolean_zero = format!("{prefix}.boolean_zero"); - let claim_expr = format!("{prefix}.claim_expr"); - let rows = vec![ - relation_output_field_expr( + let mut rows = Vec::new(); + let mut term_symbols = Vec::with_capacity(family.terms.len()); + let mut gamma_powers = BTreeMap::new(); + for (term_index, term) in family.terms.iter().enumerate() { + if term.function != RelationOutputFunctionKind::BooleanZero { + return Err(EmitError::new(format!( + "{stage} relation output function family @{family_symbol} has unsupported function" + ))); + } + let square = format!("{prefix}.term{term_index}.boolean_zero.square"); + let boolean_zero = format!("{prefix}.term{term_index}.boolean_zero"); + rows.push(relation_output_field_expr( square.clone(), "field.product", vec![term.eval.clone(), term.eval.clone()], - ), - relation_output_field_expr( + )); + rows.push(relation_output_field_expr( boolean_zero.clone(), "field.sub", vec![square, term.eval.clone()], - ), - relation_output_field_expr( - claim_expr.clone(), - "field.product", - vec![boolean_zero, term.factors[0].clone()], - ), - ]; + )); + let mut operands = Vec::new(); + if let Some(gamma) = &family.gamma { + if term.gamma_power_offset > 0 { + operands.push(eval_family_gamma_power( + term.gamma_power_offset, + gamma, + prefix, + &mut gamma_powers, + &mut rows, + )); + } + } else if term.gamma_power_offset > 0 { + return Err(EmitError::new(format!( + "{stage} relation output function family @{family_symbol} has gamma power without gamma" + ))); + } + operands.push(boolean_zero); + operands.extend(term.factors.iter().cloned()); + push_relation_output_product_term( + prefix, + term_index, + operands, + &mut term_symbols, + &mut rows, + ); + } + let claim_expr = format!("{prefix}.claim_expr"); + rows.push(relation_output_field_expr( + claim_expr.clone(), + "field.sum", + term_symbols, + )); claim.expected_output = claim_expr; let _removed_family = relation_output_function_families.remove(family_index); Ok(rows) @@ -894,11 +917,12 @@ where .iter() .map(|family| (family.symbol.as_str(), family)) .collect(); - let relation_output_function_families_by_symbol: BTreeMap<_, _> = - relation_output_function_families - .iter() - .map(|family| (family.symbol.as_str(), family)) - .collect(); + if let Some(family) = relation_output_function_families.first() { + return Err(EmitError::new(format!( + "{stage} relation output function family @{} must be lowered before resolving relation outputs", + family.symbol + ))); + } let field_exprs_by_symbol: BTreeMap<_, _> = field_exprs .iter() .map(|expr| (expr.symbol(), expr)) @@ -939,7 +963,6 @@ where let dependencies = output_dependency_closure( &relation_output_eval_families_by_symbol, &relation_output_product_families_by_symbol, - &relation_output_function_families_by_symbol, &field_exprs_by_symbol, std::iter::once(claim.expected_output.as_str()), ); @@ -953,17 +976,11 @@ where .filter(|family| dependencies.contains_product_family(&family.symbol)) .cloned() .collect(); - let function_families = relation_output_function_families - .iter() - .filter(|family| dependencies.contains_function_family(&family.symbol)) - .cloned() - .collect(); Ok(RelationOutputPlan { relation: claim.relation, structured_polynomial_evals, eval_families, product_families, - function_families, local_scalars: Vec::new(), expected_output: claim.expected_output, }) @@ -977,14 +994,12 @@ enum OutputDependencyNode { FieldExpr(String), EvalFamily(String), ProductFamily(String), - FunctionFamily(String), } #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] enum OutputFamilyDependency { Eval(String), Product(String), - Function(String), } #[derive(Default)] @@ -1004,18 +1019,11 @@ impl OutputDependencyClosure { |family| matches!(family, OutputFamilyDependency::Product(value) if value == symbol), ) } - - fn contains_function_family(&self, symbol: &str) -> bool { - self.families.iter().any( - |family| matches!(family, OutputFamilyDependency::Function(value) if value == symbol), - ) - } } fn output_dependency_closure<'a, T>( relation_output_eval_families_by_symbol: &BTreeMap<&str, &RelationOutputEvalFamilyPlan>, relation_output_product_families_by_symbol: &BTreeMap<&str, &RelationOutputProductFamilyPlan>, - relation_output_function_families_by_symbol: &BTreeMap<&str, &RelationOutputFunctionFamilyPlan>, field_exprs_by_symbol: &BTreeMap<&str, &T>, roots: impl Iterator, ) -> OutputDependencyClosure @@ -1029,7 +1037,6 @@ where output_dependency_node( relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, field_exprs_by_symbol, symbol, ) @@ -1049,7 +1056,6 @@ where output_dependency_node( relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, field_exprs_by_symbol, operand, ) @@ -1066,7 +1072,6 @@ where stack.push(output_dependency_node( relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, field_exprs_by_symbol, &family.gamma, )); @@ -1074,7 +1079,6 @@ where output_dependency_node( relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, field_exprs_by_symbol, eval, ) @@ -1083,7 +1087,6 @@ where output_dependency_node( relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, field_exprs_by_symbol, &term.factor, ) @@ -1093,7 +1096,6 @@ where output_dependency_node( relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, field_exprs_by_symbol, factor, ) @@ -1112,7 +1114,6 @@ where output_dependency_node( relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, field_exprs_by_symbol, gamma, ) @@ -1122,7 +1123,6 @@ where output_dependency_node( relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, field_exprs_by_symbol, eval, ) @@ -1131,43 +1131,6 @@ where output_dependency_node( relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, - field_exprs_by_symbol, - factor, - ) - })); - } - } - OutputDependencyNode::FunctionFamily(symbol) => { - let Some(family) = relation_output_function_families_by_symbol.get(symbol.as_str()) - else { - continue; - }; - let _inserted = dependencies - .families - .insert(OutputFamilyDependency::Function(family.symbol.clone())); - stack.extend(family.gamma.iter().map(|gamma| { - output_dependency_node( - relation_output_eval_families_by_symbol, - relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, - field_exprs_by_symbol, - gamma, - ) - })); - for term in &family.terms { - stack.push(output_dependency_node( - relation_output_eval_families_by_symbol, - relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, - field_exprs_by_symbol, - &term.eval, - )); - stack.extend(term.factors.iter().map(|factor| { - output_dependency_node( - relation_output_eval_families_by_symbol, - relation_output_product_families_by_symbol, - relation_output_function_families_by_symbol, field_exprs_by_symbol, factor, ) @@ -1182,7 +1145,6 @@ where fn output_dependency_node( relation_output_eval_families_by_symbol: &BTreeMap<&str, &RelationOutputEvalFamilyPlan>, relation_output_product_families_by_symbol: &BTreeMap<&str, &RelationOutputProductFamilyPlan>, - relation_output_function_families_by_symbol: &BTreeMap<&str, &RelationOutputFunctionFamilyPlan>, field_exprs_by_symbol: &BTreeMap<&str, &impl FieldExprDependencies>, symbol: &str, ) -> OutputDependencyNode { @@ -1190,8 +1152,6 @@ fn output_dependency_node( OutputDependencyNode::EvalFamily(symbol.to_owned()) } else if relation_output_product_families_by_symbol.contains_key(symbol) { OutputDependencyNode::ProductFamily(symbol.to_owned()) - } else if relation_output_function_families_by_symbol.contains_key(symbol) { - OutputDependencyNode::FunctionFamily(symbol.to_owned()) } else if field_exprs_by_symbol.contains_key(symbol) { OutputDependencyNode::FieldExpr(symbol.to_owned()) } else { @@ -1655,7 +1615,6 @@ mod tests { .collect::>(); assert_eq!(family_symbols, vec!["inner.family", "outer.family"]); assert!(claim.product_families.is_empty()); - assert!(claim.function_families.is_empty()); Ok(()) } @@ -1707,12 +1666,11 @@ mod tests { .map(|family| family.symbol.as_str()) .collect::>(); assert_eq!(family_symbols, vec!["product.family"]); - assert!(claim.function_families.is_empty()); Ok(()) } #[test] - fn resolves_function_families_reachable_through_field_expressions() -> Result<(), EmitError> { + fn resolve_rejects_unlowered_function_families() -> Result<(), EmitError> { let function_family = RelationOutputFunctionFamilyPlan { symbol: "function.family".to_owned(), gamma: Some("function.gamma".to_owned()), @@ -1723,43 +1681,32 @@ mod tests { factors: vec!["function.factor.expr".to_owned()], }], }; - let field_exprs = vec![ - TestFieldExpr { - symbol: "claim.expr".to_owned(), - operands: vec!["function.family".to_owned()], - }, - TestFieldExpr { - symbol: "function.factor.expr".to_owned(), - operands: vec!["unrelated.scalar".to_owned()], - }, - ]; let claim_asts = vec![RelationOutputAst { relation: "relation".to_owned(), polynomial_evals: Vec::new(), polynomial_eval_operands: Vec::new(), - expected_output: "claim.expr".to_owned(), + expected_output: "function.family".to_owned(), }]; - let claims = resolve_relation_outputs( + let error = match resolve_relation_outputs( "test", &[], &[], &[], &[function_family], - &field_exprs, + &[] as &[TestFieldExpr], claim_asts, - )?; - let claim = claims - .first() - .ok_or_else(|| EmitError::new("missing resolved relation output"))?; - assert!(claim.eval_families.is_empty()); - assert!(claim.product_families.is_empty()); - let family_symbols = claim - .function_families - .iter() - .map(|family| family.symbol.as_str()) - .collect::>(); - assert_eq!(family_symbols, vec!["function.family"]); + ) { + Ok(_) => { + return Err(EmitError::new( + "unlowered function family should fail relation output resolution", + )); + } + Err(error) => error, + }; + assert!(error + .to_string() + .contains("test relation output function family @function.family must be lowered")); Ok(()) } diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 904c046ea9..593e6cfdd6 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1558,48 +1558,58 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(verifier_program.relation_output_values.len(), 8); assert!(verifier_program.relation_output_eval_families.is_empty()); assert!(verifier_program.relation_output_product_families.is_empty()); - assert_eq!(verifier_program.relation_output_function_families.len(), 1); + assert!(verifier_program + .relation_output_function_families + .is_empty()); assert_eq!(verifier_program.relation_outputs.len(), 6); let total_booleanity_ra = params.instruction_d + params.bytecode_d + params.ram_d; - let booleanity_function_families = verifier_program - .relation_output_function_families + let booleanity_exprs = verifier_program + .field_exprs .iter() - .filter(|family| family.symbol == "stage6.booleanity.output.family") + .filter(|expr| expr.symbol.starts_with("stage6.booleanity.output.")) .collect::>(); - assert_eq!(booleanity_function_families.len(), 1); - let booleanity_function_family = booleanity_function_families[0]; - assert_eq!( - booleanity_function_family.gamma, - Some("stage6.booleanity.gamma".to_owned()) - ); - assert_eq!(booleanity_function_family.terms.len(), total_booleanity_ra); - assert_eq!(booleanity_function_family.terms[0].gamma_power_offset, 0); - assert_eq!(booleanity_function_family.terms[1].gamma_power_offset, 2); - assert_eq!( - booleanity_function_family.terms[total_booleanity_ra - 1].gamma_power_offset, - 2 * (total_booleanity_ra - 1) - ); - assert_eq!(booleanity_function_family.terms[0].function, "boolean_zero"); - assert_eq!( - booleanity_function_family.terms[0].eval, - "stage6.booleanity.eval.InstructionRa_0" - ); - assert_eq!( - booleanity_function_family.terms[params.instruction_d].eval, - "stage6.booleanity.eval.BytecodeRa_0" - ); - assert_eq!( - booleanity_function_family.terms[params.instruction_d + params.bytecode_d].eval, - "stage6.booleanity.eval.RamRa_0" - ); - assert_eq!( - booleanity_function_family.terms[0].factors, - vec!["stage6.booleanity.output.eq.InstructionRa0".to_owned()] - ); - assert!(verifier_program - .relation_output_function_families - .iter() - .all(|family| family.symbol != "stage6.hamming_booleanity.output.family")); + assert!(booleanity_exprs.iter().any(|expr| { + expr.symbol == "stage6.booleanity.output.term0.boolean_zero.square" + && expr.formula == "field.product" + && expr.operands + == vec![ + "stage6.booleanity.eval.InstructionRa_0".to_owned(), + "stage6.booleanity.eval.InstructionRa_0".to_owned(), + ] + })); + assert!(booleanity_exprs.iter().any(|expr| { + expr.symbol == "stage6.booleanity.output.term0.boolean_zero" + && expr.formula == "field.sub" + && expr.operands + == vec![ + "stage6.booleanity.output.term0.boolean_zero.square".to_owned(), + "stage6.booleanity.eval.InstructionRa_0".to_owned(), + ] + })); + assert!(booleanity_exprs.iter().any(|expr| { + expr.symbol == "stage6.booleanity.output.term0" + && expr.formula == "field.product" + && expr.operands + == vec![ + "stage6.booleanity.output.term0.boolean_zero".to_owned(), + "stage6.booleanity.output.eq.InstructionRa0".to_owned(), + ] + })); + assert!(booleanity_exprs.iter().any(|expr| { + expr.symbol == "stage6.booleanity.output.gamma_pow_2" + && expr.formula == "field.pow:2" + && expr.operands == vec!["stage6.booleanity.gamma".to_owned()] + })); + assert!(booleanity_exprs.iter().any(|expr| { + expr.symbol + == format!( + "stage6.booleanity.output.gamma_pow_{}", + 2 * (total_booleanity_ra - 1) + ) + })); + assert!(booleanity_exprs.iter().any(|expr| { + expr.symbol == "stage6.booleanity.output.claim_expr" && expr.formula == "field.sum" + })); let hamming_expr_symbols = verifier_program .field_exprs .iter() @@ -1609,8 +1619,9 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!( hamming_expr_symbols, vec![ - "stage6.hamming_booleanity.output.boolean_zero.square", - "stage6.hamming_booleanity.output.boolean_zero", + "stage6.hamming_booleanity.output.term0.boolean_zero.square", + "stage6.hamming_booleanity.output.term0.boolean_zero", + "stage6.hamming_booleanity.output.term0", "stage6.hamming_booleanity.output.claim_expr" ] ); @@ -1713,19 +1724,14 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(inc_claims.len(), 1); assert!(inc_claims[0].eval_families.is_empty()); assert!(inc_claims[0].product_families.is_empty()); - assert!(inc_claims[0].function_families.is_empty()); let booleanity_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.booleanity.output.family") + .filter(|claim| claim.expected_output == "stage6.booleanity.output.claim_expr") .collect::>(); assert_eq!(booleanity_claims.len(), 1); assert!(booleanity_claims[0].eval_families.is_empty()); assert!(booleanity_claims[0].product_families.is_empty()); - assert_eq!( - booleanity_claims[0].function_families, - vec![booleanity_function_family.clone()] - ); assert_eq!( booleanity_claims[0].structured_polynomial_evals[0].symbol, "stage6.booleanity.output.eq.InstructionRa0" @@ -1739,7 +1745,6 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(hamming_claims.len(), 1); assert!(hamming_claims[0].eval_families.is_empty()); assert!(hamming_claims[0].product_families.is_empty()); - assert!(hamming_claims[0].function_families.is_empty()); let ram_ra_claims = verifier_program .relation_outputs .iter() @@ -1748,7 +1753,6 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(ram_ra_claims.len(), 1); assert!(ram_ra_claims[0].eval_families.is_empty()); assert!(ram_ra_claims[0].product_families.is_empty()); - assert!(ram_ra_claims[0].function_families.is_empty()); let instruction_ra_claims = verifier_program .relation_outputs .iter() @@ -1757,7 +1761,6 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(instruction_ra_claims.len(), 1); assert!(instruction_ra_claims[0].eval_families.is_empty()); assert!(instruction_ra_claims[0].product_families.is_empty()); - assert!(instruction_ra_claims[0].function_families.is_empty()); let bytecode_claims = verifier_program .relation_outputs .iter() @@ -1767,7 +1770,6 @@ fn stage6_rust_targets_extract_and_compile() { assert!(bytecode_claims[0].structured_polynomial_evals.is_empty()); assert!(bytecode_claims[0].eval_families.is_empty()); assert!(bytecode_claims[0].product_families.is_empty()); - assert!(bytecode_claims[0].function_families.is_empty()); let bytecode_output_exprs = verifier_program .field_exprs .iter() @@ -1900,7 +1902,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(verifier_source .source .contains("stage6.booleanity.output.eq.InstructionRa0")); - assert!(verifier_source + assert!(!verifier_source .source .contains("stage6.booleanity.output.family")); assert!(verifier_source @@ -1920,10 +1922,10 @@ fn stage6_rust_targets_extract_and_compile() { .source .contains("expected_inc_claim_reduction")); assert!(verifier_source.source.contains("Stage6RelationOutputPlan")); - assert!(verifier_source + assert!(!verifier_source .source .contains("RelationOutputFunctionFamilyPlan")); - assert!(verifier_source + assert!(!verifier_source .source .contains("STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES")); assert!(!verifier_source @@ -1941,7 +1943,7 @@ fn stage6_rust_targets_extract_and_compile() { assert!(!verifier_source .source .contains("STAGE6_RELATION_OUTPUT_5_PRODUCT_FAMILIES")); - assert!(verifier_source + assert!(!verifier_source .source .contains("stage6.booleanity.output.family")); assert!(verifier_source @@ -1958,7 +1960,7 @@ fn stage6_rust_targets_extract_and_compile() { .contains("stage6.hamming_booleanity.output.claim_expr")); assert!(verifier_source .source - .contains("stage6.hamming_booleanity.output.boolean_zero")); + .contains("stage6.hamming_booleanity.output.term0.boolean_zero")); assert!(!verifier_source .source .contains("stage6.ram_ra_virtual.output.family")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 03dba5ad2a..5ba56afbca 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -385,19 +385,6 @@ fn generated_sumcheck_point_order(value: &str) -> bolt_verifier_runtime::Sumchec } } -#[expect( - clippy::panic, - reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" -)] -fn generated_relation_output_function_kind( - value: &str, -) -> bolt_verifier_runtime::RelationOutputFunctionKind { - match value { - "boolean_zero" => bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, - value => panic!("unsupported generated output function `{value}`"), - } -} - macro_rules! stage_program_step_kind { (kernel, $module:ident, $value:expr) => { super::leak_str($value) @@ -741,33 +728,6 @@ macro_rules! define_stage_adapter_impl { }) .collect(), ), - function_families: super::leak_slice( - plan.function_families - .iter() - .map(|family| bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { - symbol: super::leak_str(&family.symbol), - gamma: family.gamma.as_ref().map(|gamma| super::leak_str(gamma)), - terms: super::leak_slice( - family - .terms - .iter() - .map(|term| bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { - gamma_power_offset: term.gamma_power_offset, - function: super::generated_relation_output_function_kind(term.function.as_str()), - eval: super::leak_str(&term.eval), - factors: super::leak_slice( - term - .factors - .iter() - .map(|symbol| super::leak_str(symbol)) - .collect(), - ), - }) - .collect(), - ), - }) - .collect(), - ), local_scalars: super::leak_str_slice(&plan.local_scalars), expected_output: super::leak_str(&plan.expected_output), }) diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 88f71aecde..9a06828df6 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -218,9 +218,9 @@ pub const STAGE3_RELATION_OUTPUT_VALUES: &[Stage3StructuredPolynomialEvalPlan] = ]; pub const STAGE3_RELATION_OUTPUTS: &[Stage3RelationOutputPlan] = &[ - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextPC", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", index: 1 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", index: 2 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.registers.output.eq.RdWriteValue", index: 3 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextPC", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", index: 1 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", index: 2 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.registers.output.eq.RdWriteValue", index: 3 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index f33a64beb3..71cf3c6301 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -180,8 +180,8 @@ pub const STAGE4_RELATION_OUTPUT_VALUES: &[Stage4StructuredPolynomialEvalPlan] = ]; pub const STAGE4_RELATION_OUTPUTS: &[Stage4RelationOutputPlan] = &[ - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", index: 0 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.ram_val_check.output.lt.RamValCycle", index: 1 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", index: 0 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.ram_val_check.output.lt.RamValCycle", index: 1 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 693aab6b8a..cddd0ef649 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -420,9 +420,9 @@ pub const STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::Re pub const STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; pub const STAGE5_RELATION_OUTPUTS: &[Stage5RelationOutputPlan] = &[ - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", index: 1 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", index: 2 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", index: 3 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", index: 4 }], eval_families: &[], product_families: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES, function_families: &[], local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", index: 1 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", index: 2 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", index: 3 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", index: 4 }], eval_families: &[], product_families: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES, local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index fe8f31d987..eda545bc08 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -294,11 +294,30 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term3.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term3.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_3"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_pow", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term4.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_4"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_pow", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term5.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_5"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_pow", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term6.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term6.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_6"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_pow", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.claim.term7.gamma_term", Stage6FieldExprKind::Mul, &["stage6.instruction_ra_virtual.claim.term7.gamma_pow", "stage6.input.stage5.instruction_read_raf.InstructionRa_7"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage5.instruction_read_raf.InstructionRa_0", "stage6.instruction_ra_virtual.claim.term1.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial0", "stage6.instruction_ra_virtual.claim.term2.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial1", "stage6.instruction_ra_virtual.claim.term3.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial3", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial2", "stage6.instruction_ra_virtual.claim.term4.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial4", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial3", "stage6.instruction_ra_virtual.claim.term5.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial5", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial4", "stage6.instruction_ra_virtual.claim.term6.gamma_term"]), stage6_field_expr("stage6.instruction_ra_virtual.claim_expr.partial6", Stage6FieldExprKind::Add, &["stage6.instruction_ra_virtual.claim_expr.partial5", "stage6.instruction_ra_virtual.claim.term7.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_pow", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_pow", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term", Stage6FieldExprKind::Mul, &["stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_pow", "stage6.input.stage5.registers_val_evaluation.RdInc"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial0", Stage6FieldExprKind::Add, &["stage6.input.stage2.ram_read_write.RamInc", "stage6.inc_claim_reduction.claim.ram_inc_stage4.gamma_term"]), - stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.eval.HammingWeight", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.hamming_booleanity.output.boolean_zero.square", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.output.boolean_zero", "stage6.hamming_booleanity.output.eq.LookupOutput"]), stage6_field_expr("stage6.inc_claim_reduction.output.term0", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.eq.RamIncStage2"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term1", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.gamma_pow_1", "stage6.inc_claim_reduction.output.eq.RamIncStage4"]), - stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term2", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term3", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_3", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.inc_claim_reduction.output.term0", "stage6.inc_claim_reduction.output.term1", "stage6.inc_claim_reduction.output.term2", "stage6.inc_claim_reduction.output.term3"]), stage6_field_expr("stage6.ram_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3", "stage6.ram_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.ram_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.ram_ra_virtual.output.term0"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.instruction_ra_virtual.output.eq.Cycle"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term1", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_1", "stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term2", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_2", "stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term3", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term4", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.instruction_ra_virtual.output.eq.Cycle"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term5", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), stage6_field_expr("stage6.bytecode_read_raf.output.product.BytecodeRa", Stage6FieldExprKind::FieldVectorProduct, &["stage6.bytecode_read_raf.eval.BytecodeRa"]), - stage6_field_expr("stage6.bytecode_read_raf.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.output.product.BytecodeRa"]), + stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial1", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial0", "stage6.inc_claim_reduction.claim.rd_inc_stage4.gamma_term"]), stage6_field_expr("stage6.inc_claim_reduction.claim_expr.partial2", Stage6FieldExprKind::Add, &["stage6.inc_claim_reduction.claim_expr.partial1", "stage6.inc_claim_reduction.claim.rd_inc_stage5.gamma_term"]), stage6_field_expr("stage6.booleanity.output.term0.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_0", "stage6.booleanity.eval.InstructionRa_0"]), stage6_field_expr("stage6.booleanity.output.term0.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term0.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_0"]), stage6_field_expr("stage6.booleanity.output.term0", Stage6FieldExprKind::Product, &["stage6.booleanity.output.term0.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term1.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_1", "stage6.booleanity.eval.InstructionRa_1"]), stage6_field_expr("stage6.booleanity.output.term1.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term1.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_1"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term1", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_2", "stage6.booleanity.output.term1.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term2.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_2", "stage6.booleanity.eval.InstructionRa_2"]), stage6_field_expr("stage6.booleanity.output.term2.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term2.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_2"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term2", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_4", "stage6.booleanity.output.term2.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term3.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_3", "stage6.booleanity.eval.InstructionRa_3"]), stage6_field_expr("stage6.booleanity.output.term3.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term3.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_3"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term3", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_6", "stage6.booleanity.output.term3.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term4.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_4", "stage6.booleanity.eval.InstructionRa_4"]), stage6_field_expr("stage6.booleanity.output.term4.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term4.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_4"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_8", Stage6FieldExprKind::Pow(8), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term4", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_8", "stage6.booleanity.output.term4.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term5.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_5", "stage6.booleanity.eval.InstructionRa_5"]), stage6_field_expr("stage6.booleanity.output.term5.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term5.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_5"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_10", Stage6FieldExprKind::Pow(10), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term5", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_10", "stage6.booleanity.output.term5.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term6.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_6", "stage6.booleanity.eval.InstructionRa_6"]), stage6_field_expr("stage6.booleanity.output.term6.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term6.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_6"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_12", Stage6FieldExprKind::Pow(12), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term6", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_12", "stage6.booleanity.output.term6.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term7.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_7", "stage6.booleanity.eval.InstructionRa_7"]), stage6_field_expr("stage6.booleanity.output.term7.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term7.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_7"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_14", Stage6FieldExprKind::Pow(14), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term7", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_14", "stage6.booleanity.output.term7.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term8.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_8", "stage6.booleanity.eval.InstructionRa_8"]), stage6_field_expr("stage6.booleanity.output.term8.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term8.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_8"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_16", Stage6FieldExprKind::Pow(16), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term8", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_16", "stage6.booleanity.output.term8.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term9.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_9", "stage6.booleanity.eval.InstructionRa_9"]), stage6_field_expr("stage6.booleanity.output.term9.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term9.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_9"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_18", Stage6FieldExprKind::Pow(18), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term9", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_18", "stage6.booleanity.output.term9.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term10.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_10", "stage6.booleanity.eval.InstructionRa_10"]), stage6_field_expr("stage6.booleanity.output.term10.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term10.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_10"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_20", Stage6FieldExprKind::Pow(20), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term10", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_20", "stage6.booleanity.output.term10.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term11.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_11", "stage6.booleanity.eval.InstructionRa_11"]), stage6_field_expr("stage6.booleanity.output.term11.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term11.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_11"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_22", Stage6FieldExprKind::Pow(22), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term11", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_22", "stage6.booleanity.output.term11.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term12.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_12", "stage6.booleanity.eval.InstructionRa_12"]), stage6_field_expr("stage6.booleanity.output.term12.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term12.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_12"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_24", Stage6FieldExprKind::Pow(24), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term12", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_24", "stage6.booleanity.output.term12.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term13.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_13", "stage6.booleanity.eval.InstructionRa_13"]), stage6_field_expr("stage6.booleanity.output.term13.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term13.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_13"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_26", Stage6FieldExprKind::Pow(26), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term13", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_26", "stage6.booleanity.output.term13.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term14.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_14", "stage6.booleanity.eval.InstructionRa_14"]), stage6_field_expr("stage6.booleanity.output.term14.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term14.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_14"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_28", Stage6FieldExprKind::Pow(28), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term14", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_28", "stage6.booleanity.output.term14.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term15.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_15", "stage6.booleanity.eval.InstructionRa_15"]), stage6_field_expr("stage6.booleanity.output.term15.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term15.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_15"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_30", Stage6FieldExprKind::Pow(30), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term15", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_30", "stage6.booleanity.output.term15.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term16.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_16", "stage6.booleanity.eval.InstructionRa_16"]), stage6_field_expr("stage6.booleanity.output.term16.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term16.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_16"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_32", Stage6FieldExprKind::Pow(32), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term16", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_32", "stage6.booleanity.output.term16.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term17.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_17", "stage6.booleanity.eval.InstructionRa_17"]), stage6_field_expr("stage6.booleanity.output.term17.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term17.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_17"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_34", Stage6FieldExprKind::Pow(34), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term17", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_34", "stage6.booleanity.output.term17.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term18.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_18", "stage6.booleanity.eval.InstructionRa_18"]), stage6_field_expr("stage6.booleanity.output.term18.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term18.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_18"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_36", Stage6FieldExprKind::Pow(36), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term18", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_36", "stage6.booleanity.output.term18.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term19.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_19", "stage6.booleanity.eval.InstructionRa_19"]), stage6_field_expr("stage6.booleanity.output.term19.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term19.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_19"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_38", Stage6FieldExprKind::Pow(38), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term19", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_38", "stage6.booleanity.output.term19.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term20.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_20", "stage6.booleanity.eval.InstructionRa_20"]), stage6_field_expr("stage6.booleanity.output.term20.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term20.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_20"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_40", Stage6FieldExprKind::Pow(40), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term20", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_40", "stage6.booleanity.output.term20.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term21.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_21", "stage6.booleanity.eval.InstructionRa_21"]), stage6_field_expr("stage6.booleanity.output.term21.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term21.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_21"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_42", Stage6FieldExprKind::Pow(42), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term21", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_42", "stage6.booleanity.output.term21.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term22.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_22", "stage6.booleanity.eval.InstructionRa_22"]), stage6_field_expr("stage6.booleanity.output.term22.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term22.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_22"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_44", Stage6FieldExprKind::Pow(44), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term22", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_44", "stage6.booleanity.output.term22.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term23.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_23", "stage6.booleanity.eval.InstructionRa_23"]), stage6_field_expr("stage6.booleanity.output.term23.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term23.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_23"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_46", Stage6FieldExprKind::Pow(46), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term23", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_46", "stage6.booleanity.output.term23.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term24.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_24", "stage6.booleanity.eval.InstructionRa_24"]), stage6_field_expr("stage6.booleanity.output.term24.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term24.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_24"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_48", Stage6FieldExprKind::Pow(48), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term24", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_48", "stage6.booleanity.output.term24.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term25.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_25", "stage6.booleanity.eval.InstructionRa_25"]), stage6_field_expr("stage6.booleanity.output.term25.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term25.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_25"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_50", Stage6FieldExprKind::Pow(50), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term25", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_50", "stage6.booleanity.output.term25.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term26.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_26", "stage6.booleanity.eval.InstructionRa_26"]), stage6_field_expr("stage6.booleanity.output.term26.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term26.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_26"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_52", Stage6FieldExprKind::Pow(52), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term26", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_52", "stage6.booleanity.output.term26.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term27.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_27", "stage6.booleanity.eval.InstructionRa_27"]), stage6_field_expr("stage6.booleanity.output.term27.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term27.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_27"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_54", Stage6FieldExprKind::Pow(54), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term27", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_54", "stage6.booleanity.output.term27.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term28.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_28", "stage6.booleanity.eval.InstructionRa_28"]), stage6_field_expr("stage6.booleanity.output.term28.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term28.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_28"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_56", Stage6FieldExprKind::Pow(56), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term28", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_56", "stage6.booleanity.output.term28.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term29.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_29", "stage6.booleanity.eval.InstructionRa_29"]), stage6_field_expr("stage6.booleanity.output.term29.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term29.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_29"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_58", Stage6FieldExprKind::Pow(58), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term29", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_58", "stage6.booleanity.output.term29.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term30.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_30", "stage6.booleanity.eval.InstructionRa_30"]), stage6_field_expr("stage6.booleanity.output.term30.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term30.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_30"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_60", Stage6FieldExprKind::Pow(60), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term30", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_60", "stage6.booleanity.output.term30.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term31.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.InstructionRa_31", "stage6.booleanity.eval.InstructionRa_31"]), stage6_field_expr("stage6.booleanity.output.term31.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term31.boolean_zero.square", "stage6.booleanity.eval.InstructionRa_31"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_62", Stage6FieldExprKind::Pow(62), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term31", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_62", "stage6.booleanity.output.term31.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term32.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.BytecodeRa_0", "stage6.booleanity.eval.BytecodeRa_0"]), stage6_field_expr("stage6.booleanity.output.term32.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term32.boolean_zero.square", "stage6.booleanity.eval.BytecodeRa_0"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_64", Stage6FieldExprKind::Pow(64), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term32", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_64", "stage6.booleanity.output.term32.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term33.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.BytecodeRa_1", "stage6.booleanity.eval.BytecodeRa_1"]), stage6_field_expr("stage6.booleanity.output.term33.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term33.boolean_zero.square", "stage6.booleanity.eval.BytecodeRa_1"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_66", Stage6FieldExprKind::Pow(66), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term33", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_66", "stage6.booleanity.output.term33.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term34.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.BytecodeRa_2", "stage6.booleanity.eval.BytecodeRa_2"]), stage6_field_expr("stage6.booleanity.output.term34.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term34.boolean_zero.square", "stage6.booleanity.eval.BytecodeRa_2"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_68", Stage6FieldExprKind::Pow(68), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term34", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_68", "stage6.booleanity.output.term34.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term35.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.RamRa_0", "stage6.booleanity.eval.RamRa_0"]), stage6_field_expr("stage6.booleanity.output.term35.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term35.boolean_zero.square", "stage6.booleanity.eval.RamRa_0"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_70", Stage6FieldExprKind::Pow(70), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term35", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_70", "stage6.booleanity.output.term35.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term36.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.RamRa_1", "stage6.booleanity.eval.RamRa_1"]), stage6_field_expr("stage6.booleanity.output.term36.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term36.boolean_zero.square", "stage6.booleanity.eval.RamRa_1"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_72", Stage6FieldExprKind::Pow(72), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term36", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_72", "stage6.booleanity.output.term36.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term37.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.RamRa_2", "stage6.booleanity.eval.RamRa_2"]), stage6_field_expr("stage6.booleanity.output.term37.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term37.boolean_zero.square", "stage6.booleanity.eval.RamRa_2"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_74", Stage6FieldExprKind::Pow(74), &["stage6.booleanity.gamma"]), + stage6_field_expr("stage6.booleanity.output.term37", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_74", "stage6.booleanity.output.term37.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.term38.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.booleanity.eval.RamRa_3", "stage6.booleanity.eval.RamRa_3"]), stage6_field_expr("stage6.booleanity.output.term38.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.booleanity.output.term38.boolean_zero.square", "stage6.booleanity.eval.RamRa_3"]), stage6_field_expr("stage6.booleanity.output.gamma_pow_76", Stage6FieldExprKind::Pow(76), &["stage6.booleanity.gamma"]), stage6_field_expr("stage6.booleanity.output.term38", Stage6FieldExprKind::Product, &["stage6.booleanity.output.gamma_pow_76", "stage6.booleanity.output.term38.boolean_zero", "stage6.booleanity.output.eq.InstructionRa0"]), stage6_field_expr("stage6.booleanity.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.booleanity.output.term0", "stage6.booleanity.output.term1", "stage6.booleanity.output.term2", "stage6.booleanity.output.term3", "stage6.booleanity.output.term4", "stage6.booleanity.output.term5", "stage6.booleanity.output.term6", "stage6.booleanity.output.term7", "stage6.booleanity.output.term8", "stage6.booleanity.output.term9", "stage6.booleanity.output.term10", "stage6.booleanity.output.term11", "stage6.booleanity.output.term12", "stage6.booleanity.output.term13", "stage6.booleanity.output.term14", "stage6.booleanity.output.term15", "stage6.booleanity.output.term16", "stage6.booleanity.output.term17", "stage6.booleanity.output.term18", "stage6.booleanity.output.term19", "stage6.booleanity.output.term20", "stage6.booleanity.output.term21", "stage6.booleanity.output.term22", "stage6.booleanity.output.term23", "stage6.booleanity.output.term24", "stage6.booleanity.output.term25", "stage6.booleanity.output.term26", "stage6.booleanity.output.term27", "stage6.booleanity.output.term28", "stage6.booleanity.output.term29", "stage6.booleanity.output.term30", "stage6.booleanity.output.term31", "stage6.booleanity.output.term32", "stage6.booleanity.output.term33", "stage6.booleanity.output.term34", "stage6.booleanity.output.term35", "stage6.booleanity.output.term36", "stage6.booleanity.output.term37", "stage6.booleanity.output.term38"]), stage6_field_expr("stage6.hamming_booleanity.output.term0.boolean_zero.square", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.eval.HammingWeight", "stage6.hamming_booleanity.eval.HammingWeight"]), stage6_field_expr("stage6.hamming_booleanity.output.term0.boolean_zero", Stage6FieldExprKind::Sub, &["stage6.hamming_booleanity.output.term0.boolean_zero.square", "stage6.hamming_booleanity.eval.HammingWeight"]), + stage6_field_expr("stage6.hamming_booleanity.output.term0", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.output.term0.boolean_zero", "stage6.hamming_booleanity.output.eq.LookupOutput"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.hamming_booleanity.output.term0"]), stage6_field_expr("stage6.inc_claim_reduction.output.term0", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.eq.RamIncStage2"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term1", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.gamma_pow_1", "stage6.inc_claim_reduction.output.eq.RamIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term2", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), + stage6_field_expr("stage6.inc_claim_reduction.output.term3", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_3", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.inc_claim_reduction.output.term0", "stage6.inc_claim_reduction.output.term1", "stage6.inc_claim_reduction.output.term2", "stage6.inc_claim_reduction.output.term3"]), stage6_field_expr("stage6.ram_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3", "stage6.ram_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.ram_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.ram_ra_virtual.output.term0"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term1", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_1", "stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.term2", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_2", "stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term3", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term4", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term5", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), stage6_field_expr("stage6.bytecode_read_raf.output.product.BytecodeRa", Stage6FieldExprKind::FieldVectorProduct, &["stage6.bytecode_read_raf.eval.BytecodeRa"]), stage6_field_expr("stage6.bytecode_read_raf.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.output.product.BytecodeRa"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -648,59 +667,14 @@ pub const STAGE6_RELATION_OUTPUT_VALUES: &[Stage6StructuredPolynomialEvalPlan] = Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.registers_val_evaluation.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan] = &[ - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 2, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 4, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 6, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_3", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 8, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_4", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 10, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_5", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 12, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_6", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 14, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_7", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 16, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_8", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 18, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_9", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 20, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_10", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 22, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_11", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 24, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_12", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 26, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_13", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 28, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_14", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 30, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_15", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 32, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_16", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 34, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_17", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 36, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_18", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 38, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_19", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 40, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_20", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 42, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_21", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 44, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_22", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 46, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_23", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 48, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_24", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 50, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_25", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 52, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_26", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 54, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_27", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 56, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_28", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 58, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_29", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 60, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_30", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 62, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.InstructionRa_31", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 64, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 66, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 68, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.BytecodeRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 70, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_0", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 72, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_1", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 74, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_2", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, - bolt_verifier_runtime::RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 76, function: bolt_verifier_runtime::RelationOutputFunctionKind::BooleanZero, eval: "stage6.booleanity.eval.RamRa_3", factors: &["stage6.booleanity.output.eq.InstructionRa0"] }, -]; -pub const STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES: &[bolt_verifier_runtime::RelationOutputFunctionFamilyPlan] = &[ - bolt_verifier_runtime::RelationOutputFunctionFamilyPlan { symbol: "stage6.booleanity.output.family", gamma: Some("stage6.booleanity.gamma"), terms: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILY_0_TERMS }, -]; - pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], eval_families: &[], product_families: &[], function_families: STAGE6_RELATION_OUTPUT_0_FUNCTION_FAMILIES, local_scalars: &[], expected_output: "stage6.booleanity.output.family" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: &[], product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], product_families: &[], function_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage6.booleanity.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], product_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index f8683f3458..159d1b1d4d 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -327,7 +327,7 @@ pub const STAGE7_RELATION_OUTPUT_0_FAMILIES: &[bolt_verifier_runtime::RelationOu ]; pub const STAGE7_RELATION_OUTPUTS: &[Stage7RelationOutputPlan] = &[ - Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, structured_polynomial_evals: STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS, eval_families: STAGE7_RELATION_OUTPUT_0_FAMILIES, product_families: &[], function_families: &[], local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.family" }, + Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, structured_polynomial_evals: STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS, eval_families: STAGE7_RELATION_OUTPUT_0_FAMILIES, product_families: &[], local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.family" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ From e2b5bd0461837972d82e91953cbf58ef9b43af45 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 21:25:30 -0600 Subject: [PATCH 104/171] refactor(bolt): lower read-raf product output Lower Stage 5 instruction read-RAF product-family outputs into ordinary field expressions and field-vector products. Remove the generated/runtime product-family relation-output surface now that no generated verifier stage uses it. --- crates/bolt-verifier-runtime/src/lib.rs | 105 +-------------- .../jolt/emit/rust/relation_outputs.rs | 69 +--------- .../src/protocols/jolt/emit/rust/stage5.rs | 42 +++++- .../jolt/stage5_instruction_read_raf_plan.rs | 123 +++++++++--------- crates/jolt-equivalence/src/plan_adapters.rs | 39 ------ crates/jolt-verifier/src/stages/stage3.rs | 6 +- crates/jolt-verifier/src/stages/stage4.rs | 4 +- crates/jolt-verifier/src/stages/stage5.rs | 100 +++++++------- crates/jolt-verifier/src/stages/stage6.rs | 12 +- crates/jolt-verifier/src/stages/stage7.rs | 2 +- 10 files changed, 165 insertions(+), 337 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 033b9c091f..075eab1345 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -411,27 +411,11 @@ pub struct RelationOutputEvalFamilyPlan { pub item_terms: &'static [RelationOutputEvalFamilyItemTermPlan], } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct RelationOutputProductFamilyTermPlan { - pub gamma_power_offset: usize, - pub evals: &'static [&'static str], - pub eval_families: &'static [&'static str], - pub factors: &'static [&'static str], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct RelationOutputProductFamilyPlan { - pub symbol: &'static str, - pub gamma: Option<&'static str>, - pub terms: &'static [RelationOutputProductFamilyTermPlan], -} - #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: R, pub structured_polynomial_evals: &'static [StructuredPolynomialEvalRef], pub eval_families: &'static [RelationOutputEvalFamilyPlan], - pub product_families: &'static [RelationOutputProductFamilyPlan], pub local_scalars: &'static [&'static str], pub expected_output: &'static str, } @@ -1364,10 +1348,6 @@ pub fn evaluate_relation_output( let value = evaluate_relation_output_eval_family(family, store, &scratch)?; scratch.insert(family.symbol, value); } - for family in plan.product_families { - let value = evaluate_relation_output_product_family(family, store, &scratch)?; - scratch.insert(family.symbol, value); - } evaluate_available_field_exprs_with_scratch(field_exprs, store, &mut scratch)?; scratch .scalar_or(store, plan.expected_output) @@ -1489,61 +1469,6 @@ fn evaluate_relation_output_eval_family( Ok(result) } -fn evaluate_relation_output_product_family( - family: &RelationOutputProductFamilyPlan, - store: &ValueStore, - scratch: &ScratchScalars, -) -> Result { - let gamma = relation_output_family_gamma(family.gamma, store, scratch)?; - let mut result = Fr::from_u64(0); - for term in family.terms { - if term.evals.is_empty() && term.eval_families.is_empty() && term.factors.is_empty() { - return Err(RuntimePlanError::InvalidInputLength { - input: family.symbol, - expected: 1, - actual: 0, - }); - } - let mut product = pow_field(gamma, term.gamma_power_offset); - for &symbol in term.evals.iter().chain(term.factors.iter()) { - let value = scratch - .scalar_or(store, symbol) - .ok_or(RuntimePlanError::MissingValue { symbol })?; - product *= value; - } - for &family_symbol in term.eval_families { - let values = store.field_vector_or(family_symbol, |symbol| { - RuntimePlanError::MissingValue { symbol } - })?; - if values.is_empty() { - return Err(RuntimePlanError::InvalidInputLength { - input: family_symbol, - expected: 1, - actual: 0, - }); - } - for value in values { - product *= *value; - } - } - result += product; - } - Ok(result) -} - -fn relation_output_family_gamma( - gamma: Option<&'static str>, - store: &ValueStore, - scratch: &ScratchScalars, -) -> Result { - match gamma { - Some(symbol) => scratch - .scalar_or(store, symbol) - .ok_or(RuntimePlanError::MissingValue { symbol }), - None => Ok(Fr::from_u64(1)), - } -} - fn evaluate_structured_polynomial_point( plan: StructuredPolynomialPointPlan, raw_point: &[Fr], @@ -1908,9 +1833,8 @@ pub fn reverse_slice(values: &[Fr]) -> Vec { )] mod tests { use super::{ - evaluate_field_expr, evaluate_relation_output_product_family, FieldExprKind, FieldExprPlan, - Fr, NamedEvalFamilyPlan, RelationOutputProductFamilyPlan, - RelationOutputProductFamilyTermPlan, RuntimePlanError, ScratchScalars, ValueStore, + evaluate_field_expr, FieldExprKind, FieldExprPlan, Fr, NamedEvalFamilyPlan, + RuntimePlanError, ValueStore, }; #[test] @@ -1976,29 +1900,4 @@ mod tests { assert_eq!(store.try_scalar("family.ab.product"), Some(Fr::from_u64(6))); assert_eq!(store.try_scalar("family.ab.sum"), Some(Fr::from_u64(5))); } - - #[test] - fn product_family_multiplies_field_vector_terms() { - let mut store = ValueStore::default(); - store.insert_scalar("scalar.factor", Fr::from_u64(5)); - store.insert_field_vector("family.ab", vec![Fr::from_u64(2), Fr::from_u64(3)]); - - let value = evaluate_relation_output_product_family( - &RelationOutputProductFamilyPlan { - symbol: "product.family", - gamma: None, - terms: &[RelationOutputProductFamilyTermPlan { - gamma_power_offset: 0, - evals: &["scalar.factor"], - eval_families: &["family.ab"], - factors: &[], - }], - }, - &store, - &ScratchScalars::default(), - ) - .unwrap(); - - assert_eq!(value, Fr::from_u64(30)); - } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index d0dd6a9a88..71bde15b29 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -16,6 +16,12 @@ pub fn emit_verifier_relation_output_constants( emit_relation_output_value_constants(&mut source, stage_type, relation_output_values)?; let mut claims = Vec::new(); for (index, claim) in relation_outputs.iter().enumerate() { + if let Some(family) = claim.product_families.first() { + return Err(EmitError::new(format!( + "{stage_type} relation output product family @{} must be lowered before Rust verifier emission", + family.symbol + ))); + } let values_name = format!( "{}_RELATION_OUTPUT_{index}_STRUCTURED_POLYNOMIAL_EVALS", stage_type.to_ascii_uppercase() @@ -26,10 +32,9 @@ pub fn emit_verifier_relation_output_constants( &claim.structured_polynomial_evals, ); let eval_families = emit_eval_family_constants(&mut source, stage_type, index, claim); - let product_families = emit_product_family_constants(&mut source, stage_type, index, claim); let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim); claims.push(format!( - " {stage_type}RelationOutputPlan {{ relation: {}, structured_polynomial_evals: {values}, eval_families: {eval_families}, product_families: {product_families}, local_scalars: {local_scalars}, expected_output: {} }},", + " {stage_type}RelationOutputPlan {{ relation: {}, structured_polynomial_evals: {values}, eval_families: {eval_families}, local_scalars: {local_scalars}, expected_output: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, rust_str(&claim.expected_output) )); @@ -171,59 +176,6 @@ fn emit_eval_family_constants( families_name } -fn emit_product_family_constants( - source: &mut String, - stage_type: &str, - claim_index: usize, - claim: &RelationOutputPlan, -) -> String { - if claim.product_families.is_empty() { - return "&[]".to_owned(); - } - let upper_stage = stage_type.to_ascii_uppercase(); - let mut family_rows = Vec::new(); - for (family_index, family) in claim.product_families.iter().enumerate() { - let prefix = - format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_PRODUCT_FAMILY_{family_index}"); - let mut term_rows = Vec::new(); - for (term_index, term) in family.terms.iter().enumerate() { - let evals_name = format!("{prefix}_TERM_{term_index}_EVALS"); - let evals = emit_str_slice_or_inline(source, &evals_name, &term.evals); - let eval_families_name = format!("{prefix}_TERM_{term_index}_EVAL_FAMILIES"); - let eval_families = - emit_str_slice_or_inline(source, &eval_families_name, &term.eval_families); - let factors_name = format!("{prefix}_TERM_{term_index}_FACTORS"); - let factors = emit_str_slice_or_inline(source, &factors_name, &term.factors); - term_rows.push(format!( - " bolt_verifier_runtime::RelationOutputProductFamilyTermPlan {{ gamma_power_offset: {}, evals: {evals}, eval_families: {eval_families}, factors: {factors} }},", - term.gamma_power_offset - )); - } - let terms_name = format!("{prefix}_TERMS"); - let terms = term_rows.join("\n"); - push_format( - source, - format_args!( - "pub const {terms_name}: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[\n{terms}\n];\n" - ), - ); - family_rows.push(format!( - " bolt_verifier_runtime::RelationOutputProductFamilyPlan {{ symbol: {}, gamma: {}, terms: {terms_name} }},", - rust_str(&family.symbol), - optional_rust_str(family.gamma.as_deref()), - )); - } - let families_name = format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_PRODUCT_FAMILIES"); - let families = family_rows.join("\n"); - push_format( - source, - format_args!( - "pub const {families_name}: &[bolt_verifier_runtime::RelationOutputProductFamilyPlan] = &[\n{families}\n];\n\n" - ), - ); - families_name -} - fn emit_structured_polynomial_eval_refs_slice_or_inline( source: &mut String, name: &str, @@ -346,13 +298,6 @@ fn rust_str(value: &str) -> String { format!("{value:?}") } -fn optional_rust_str(value: Option<&str>) -> String { - value.map_or_else( - || "None".to_owned(), - |value| format!("Some({})", rust_str(value)), - ) -} - fn rust_str_array(values: &[String]) -> String { values .iter() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 14b0b16e47..be12492e31 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -11,6 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::rust_target_plan::FieldExprKind; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, }; @@ -767,6 +768,11 @@ impl Stage5CpuProgram { } else { self.cpu_field_value_sources() }; + let field_vector_values = if self.role == Role::Verifier { + Some(self.verifier_plan()?.field_vector_value_sources()) + } else { + None + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -774,12 +780,36 @@ impl Stage5CpuProgram { expr.operand_names.len(), expr.operands.len(), )?; - for operand in &expr.operands { - if !field_values.contains(operand) { - return Err(EmitError::new(format!( - "field expr @{} references missing field value @{operand}", - expr.symbol - ))); + let kind = FieldExprKind::from_cpu_attr(&expr.formula) + .map_err(|error| EmitError::new(error.to_string()))?; + match kind { + FieldExprKind::FieldVectorSum | FieldExprKind::FieldVectorProduct => { + verify_count( + "field vector expr operands", + &expr.symbol, + 1, + expr.operands.len(), + )?; + let operand = &expr.operands[0]; + if !field_vector_values + .as_ref() + .is_some_and(|values| values.contains(operand)) + { + return Err(EmitError::new(format!( + "field vector expr @{} references missing field vector @{operand}", + expr.symbol + ))); + } + } + _ => { + for operand in &expr.operands { + if !field_values.contains(operand) { + return Err(EmitError::new(format!( + "field expr @{} references missing field value @{operand}", + expr.symbol + ))); + } + } } } } diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index ecfbecde2c..6b0a84738e 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -1,10 +1,9 @@ use crate::emit::rust::{push_format, EmitError}; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_relation_outputs::{ - RelationOutputPlan, RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, - StructuredPolynomialEvalPlan, StructuredPolynomialEvalRefPlan, StructuredPolynomialKind, - StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment, + RelationOutputPlan, StructuredPolynomialEvalPlan, StructuredPolynomialEvalRefPlan, + StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, }; pub(crate) const STAGE5_TABLE_FLAG_EVAL_FAMILY: &str = @@ -83,38 +82,6 @@ impl Stage5InstructionReadRafEmitPlan { pub(crate) fn relation_output_plan(&self) -> Stage5InstructionReadRafOutputPlan { const PREFIX: &str = "stage5.instruction_read_raf.output"; - let table_value_family = RelationOutputProductFamilyPlan { - symbol: format!("{PREFIX}.product.LookupTableValues"), - gamma: None, - terms: self - .table_flag_evals - .evals - .iter() - .zip( - self.point_values - .iter() - .filter(|value| value.is_lookup_table()), - ) - .map( - |(flag_eval, table_value)| RelationOutputProductFamilyTermPlan { - gamma_power_offset: 0, - evals: vec![table_value.symbol.clone(), flag_eval.clone()], - eval_families: Vec::new(), - factors: Vec::new(), - }, - ) - .collect(), - }; - let ra_product_family = RelationOutputProductFamilyPlan { - symbol: format!("{PREFIX}.product.InstructionRa"), - gamma: None, - terms: vec![RelationOutputProductFamilyTermPlan { - gamma_power_offset: 0, - evals: Vec::new(), - eval_families: vec![self.instruction_ra_evals.symbol.clone()], - factors: Vec::new(), - }], - }; let eq = StructuredPolynomialEvalPlan { symbol: format!("{PREFIX}.eq.LookupOutputCycle"), polynomial: StructuredPolynomialKind::Eq, @@ -143,11 +110,41 @@ impl Stage5InstructionReadRafEmitPlan { let raf_flag_gamma_identity = format!("{PREFIX}.term.RafFlagGammaIdentity"); let raf_claim = format!("{PREFIX}.partial.RafClaim"); let gamma_raf_claim = format!("{PREFIX}.term.GammaRafClaim"); + let table_values = format!("{PREFIX}.product.LookupTableValues"); + let instruction_ra_product = format!("{PREFIX}.product.InstructionRa"); let lookup_or_raf = format!("{PREFIX}.partial.LookupOrRaf"); let eq_ra = format!("{PREFIX}.partial.EqRa"); let claim_expr = format!("{PREFIX}.claim_expr"); - let field_exprs = vec![ + let mut field_exprs = + Vec::with_capacity(self.table_flag_evals.evals.len().saturating_add(12)); + let mut table_value_terms = Vec::with_capacity(self.table_flag_evals.evals.len()); + for (index, (flag_eval, table_value)) in self + .table_flag_evals + .evals + .iter() + .zip( + self.point_values + .iter() + .filter(|value| value.is_lookup_table()), + ) + .enumerate() + { + let term = format!("{PREFIX}.term.LookupTableValue_{index}"); + table_value_terms.push(term.clone()); + field_exprs.push(output_field_expr( + term, + "field.mul", + vec![table_value.symbol.clone(), flag_eval.clone()], + )); + } + field_exprs.extend([ + output_field_expr(table_values.clone(), "field.sum", table_value_terms), + output_field_expr( + instruction_ra_product.clone(), + "field_vector.product", + vec![self.instruction_ra_evals.symbol.clone()], + ), output_field_expr( gamma_right.clone(), "field.mul", @@ -191,15 +188,15 @@ impl Stage5InstructionReadRafEmitPlan { output_field_expr( lookup_or_raf.clone(), "field.add", - vec![table_value_family.symbol.clone(), gamma_raf_claim], + vec![table_values, gamma_raf_claim], ), output_field_expr( eq_ra.clone(), "field.mul", - vec![eq.symbol.clone(), ra_product_family.symbol.clone()], + vec![eq.symbol.clone(), instruction_ra_product], ), output_field_expr(claim_expr.clone(), "field.mul", vec![eq_ra, lookup_or_raf]), - ]; + ]); Stage5InstructionReadRafOutputPlan { relation_output_values: vec![eq.clone()], @@ -211,7 +208,7 @@ impl Stage5InstructionReadRafEmitPlan { index: 0, }], eval_families: Vec::new(), - product_families: vec![table_value_family, ra_product_family], + product_families: Vec::new(), local_scalars: self .point_values .iter() @@ -447,26 +444,7 @@ mod tests { "stage5.instruction_read_raf.output.eq.LookupOutputCycle" ); assert_eq!(output_plan.claim.structured_polynomial_evals[0].index, 0); - assert_eq!(output_plan.claim.product_families.len(), 2); - assert_eq!( - output_plan.claim.product_families[0].symbol, - "stage5.instruction_read_raf.output.product.LookupTableValues" - ); - assert_eq!( - output_plan.claim.product_families[0].terms[0].evals, - vec![ - "stage5.instruction_read_raf.point_value.LookupTable_0".to_owned(), - "stage5.instruction_read_raf.eval.LookupTableFlag_0".to_owned() - ] - ); - assert_eq!( - output_plan.claim.product_families[1].terms[0].evals, - Vec::::new() - ); - assert_eq!( - output_plan.claim.product_families[1].terms[0].eval_families, - vec![STAGE5_INSTRUCTION_RA_EVAL_FAMILY.to_owned()] - ); + assert!(output_plan.claim.product_families.is_empty()); assert_eq!( output_plan.claim.local_scalars, vec![ @@ -477,6 +455,29 @@ mod tests { "stage5.instruction_read_raf.point_value.Identity".to_owned(), ] ); + assert!(output_plan.field_exprs.iter().any(|expr| { + expr.symbol == "stage5.instruction_read_raf.output.term.LookupTableValue_0" + && expr.formula == "field.mul" + && expr.operands + == vec![ + "stage5.instruction_read_raf.point_value.LookupTable_0".to_owned(), + "stage5.instruction_read_raf.eval.LookupTableFlag_0".to_owned(), + ] + })); + assert!(output_plan.field_exprs.iter().any(|expr| { + expr.symbol == "stage5.instruction_read_raf.output.product.LookupTableValues" + && expr.formula == "field.sum" + && expr.operands + == vec![ + "stage5.instruction_read_raf.output.term.LookupTableValue_0".to_owned(), + "stage5.instruction_read_raf.output.term.LookupTableValue_1".to_owned(), + ] + })); + assert!(output_plan.field_exprs.iter().any(|expr| { + expr.symbol == "stage5.instruction_read_raf.output.product.InstructionRa" + && expr.formula == "field_vector.product" + && expr.operands == vec![STAGE5_INSTRUCTION_RA_EVAL_FAMILY.to_owned()] + })); assert!(output_plan.field_exprs.iter().any(|expr| { expr.symbol == "stage5.instruction_read_raf.output.claim_expr" && expr.formula == "field.mul" diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 5ba56afbca..afdae7d758 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -689,45 +689,6 @@ macro_rules! define_stage_adapter_impl { }) .collect(), ), - product_families: super::leak_slice( - plan.product_families - .iter() - .map(|family| bolt_verifier_runtime::RelationOutputProductFamilyPlan { - symbol: super::leak_str(&family.symbol), - gamma: family.gamma.as_ref().map(|gamma| super::leak_str(gamma)), - terms: super::leak_slice( - family - .terms - .iter() - .map(|term| bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { - gamma_power_offset: term.gamma_power_offset, - evals: super::leak_slice( - term - .evals - .iter() - .map(|symbol| super::leak_str(symbol)) - .collect(), - ), - eval_families: super::leak_slice( - term - .eval_families - .iter() - .map(|symbol| super::leak_str(symbol)) - .collect(), - ), - factors: super::leak_slice( - term - .factors - .iter() - .map(|symbol| super::leak_str(symbol)) - .collect(), - ), - }) - .collect(), - ), - }) - .collect(), - ), local_scalars: super::leak_str_slice(&plan.local_scalars), expected_output: super::leak_str(&plan.expected_output), }) diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 9a06828df6..e30c0962d2 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -218,9 +218,9 @@ pub const STAGE3_RELATION_OUTPUT_VALUES: &[Stage3StructuredPolynomialEvalPlan] = ]; pub const STAGE3_RELATION_OUTPUTS: &[Stage3RelationOutputPlan] = &[ - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextPC", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", index: 1 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", index: 2 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.registers.output.eq.RdWriteValue", index: 3 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextPC", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", index: 1 }], eval_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", index: 2 }], eval_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.registers.output.eq.RdWriteValue", index: 3 }], eval_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 71cf3c6301..a45220abc8 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -180,8 +180,8 @@ pub const STAGE4_RELATION_OUTPUT_VALUES: &[Stage4StructuredPolynomialEvalPlan] = ]; pub const STAGE4_RELATION_OUTPUTS: &[Stage4RelationOutputPlan] = &[ - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", index: 0 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.ram_val_check.output.lt.RamValCycle", index: 1 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", index: 0 }], eval_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.ram_val_check.output.lt.RamValCycle", index: 1 }], eval_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index cddd0ef649..ad0b271d8b 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -110,6 +110,49 @@ pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[ Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.output.eq_combined", "stage5.ram_ra_claim_reduction.eval.RamRa"] }, Stage5FieldExprPlan { symbol: "stage5.registers_val_evaluation.output.product.RdIncRdWa", kind: Stage5FieldExprKind::Mul, operands: &["stage5.registers_val_evaluation.eval.RdInc", "stage5.registers_val_evaluation.eval.RdWa"] }, Stage5FieldExprPlan { symbol: "stage5.registers_val_evaluation.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.registers_val_evaluation.output.product.RdIncRdWa", "stage5.registers_val_evaluation.output.lt.RegistersValCycle"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_0", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_1", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_2", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_3", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_4", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_5", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_6", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_7", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_8", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_9", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_10", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_11", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_12", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_13", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_14", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_15", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_16", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_17", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_18", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_19", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_20", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_21", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_22", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_23", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_24", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_25", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_26", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_27", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_28", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_29", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_30", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_31", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_32", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_33", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_34", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_35", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_36", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_37", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_38", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_39", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_40", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.product.LookupTableValues", kind: Stage5FieldExprKind::Sum, operands: &["stage5.instruction_read_raf.output.term.LookupTableValue_0", "stage5.instruction_read_raf.output.term.LookupTableValue_1", "stage5.instruction_read_raf.output.term.LookupTableValue_2", "stage5.instruction_read_raf.output.term.LookupTableValue_3", "stage5.instruction_read_raf.output.term.LookupTableValue_4", "stage5.instruction_read_raf.output.term.LookupTableValue_5", "stage5.instruction_read_raf.output.term.LookupTableValue_6", "stage5.instruction_read_raf.output.term.LookupTableValue_7", "stage5.instruction_read_raf.output.term.LookupTableValue_8", "stage5.instruction_read_raf.output.term.LookupTableValue_9", "stage5.instruction_read_raf.output.term.LookupTableValue_10", "stage5.instruction_read_raf.output.term.LookupTableValue_11", "stage5.instruction_read_raf.output.term.LookupTableValue_12", "stage5.instruction_read_raf.output.term.LookupTableValue_13", "stage5.instruction_read_raf.output.term.LookupTableValue_14", "stage5.instruction_read_raf.output.term.LookupTableValue_15", "stage5.instruction_read_raf.output.term.LookupTableValue_16", "stage5.instruction_read_raf.output.term.LookupTableValue_17", "stage5.instruction_read_raf.output.term.LookupTableValue_18", "stage5.instruction_read_raf.output.term.LookupTableValue_19", "stage5.instruction_read_raf.output.term.LookupTableValue_20", "stage5.instruction_read_raf.output.term.LookupTableValue_21", "stage5.instruction_read_raf.output.term.LookupTableValue_22", "stage5.instruction_read_raf.output.term.LookupTableValue_23", "stage5.instruction_read_raf.output.term.LookupTableValue_24", "stage5.instruction_read_raf.output.term.LookupTableValue_25", "stage5.instruction_read_raf.output.term.LookupTableValue_26", "stage5.instruction_read_raf.output.term.LookupTableValue_27", "stage5.instruction_read_raf.output.term.LookupTableValue_28", "stage5.instruction_read_raf.output.term.LookupTableValue_29", "stage5.instruction_read_raf.output.term.LookupTableValue_30", "stage5.instruction_read_raf.output.term.LookupTableValue_31", "stage5.instruction_read_raf.output.term.LookupTableValue_32", "stage5.instruction_read_raf.output.term.LookupTableValue_33", "stage5.instruction_read_raf.output.term.LookupTableValue_34", "stage5.instruction_read_raf.output.term.LookupTableValue_35", "stage5.instruction_read_raf.output.term.LookupTableValue_36", "stage5.instruction_read_raf.output.term.LookupTableValue_37", "stage5.instruction_read_raf.output.term.LookupTableValue_38", "stage5.instruction_read_raf.output.term.LookupTableValue_39", "stage5.instruction_read_raf.output.term.LookupTableValue_40"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", kind: Stage5FieldExprKind::FieldVectorProduct, operands: &["stage5.instruction_read_raf.eval.InstructionRa"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaRightLookupOperand", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.point_value.RightLookupOperand"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.output.term.GammaRightLookupOperand"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.RafFlagLeftPlusGammaRight", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.eval.InstructionRafFlag", "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight"] }, @@ -367,62 +410,11 @@ pub const STAGE5_RELATION_OUTPUT_VALUES: &[Stage5StructuredPolynomialEvalPlan] = Stage5StructuredPolynomialEvalPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.instruction_read_raf.instance", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::YPoint, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.instruction.LookupOutput", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::AsIs } }, ]; -pub const STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"], eval_families: &[], factors: &[] }, - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"], eval_families: &[], factors: &[] }, -]; -pub const STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILY_1_TERMS: &[bolt_verifier_runtime::RelationOutputProductFamilyTermPlan] = &[ - bolt_verifier_runtime::RelationOutputProductFamilyTermPlan { gamma_power_offset: 0, evals: &[], eval_families: &["stage5.instruction_read_raf.eval.InstructionRa"], factors: &[] }, -]; -pub const STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES: &[bolt_verifier_runtime::RelationOutputProductFamilyPlan] = &[ - bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.LookupTableValues", gamma: None, terms: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILY_0_TERMS }, - bolt_verifier_runtime::RelationOutputProductFamilyPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", gamma: None, terms: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILY_1_TERMS }, -]; - pub const STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; pub const STAGE5_RELATION_OUTPUTS: &[Stage5RelationOutputPlan] = &[ - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", index: 1 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", index: 2 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", index: 3 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", index: 4 }], eval_families: &[], product_families: STAGE5_RELATION_OUTPUT_2_PRODUCT_FAMILIES, local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", index: 1 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", index: 2 }], eval_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", index: 3 }], eval_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", index: 4 }], eval_families: &[], local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index eda545bc08..68e0ad94f3 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -669,12 +669,12 @@ pub const STAGE6_RELATION_OUTPUT_VALUES: &[Stage6StructuredPolynomialEvalPlan] = pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage6.booleanity.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: &[], product_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], product_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], eval_families: &[], local_scalars: &[], expected_output: "stage6.booleanity.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], eval_families: &[], local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 159d1b1d4d..671e6ec79e 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -327,7 +327,7 @@ pub const STAGE7_RELATION_OUTPUT_0_FAMILIES: &[bolt_verifier_runtime::RelationOu ]; pub const STAGE7_RELATION_OUTPUTS: &[Stage7RelationOutputPlan] = &[ - Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, structured_polynomial_evals: STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS, eval_families: STAGE7_RELATION_OUTPUT_0_FAMILIES, product_families: &[], local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.family" }, + Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, structured_polynomial_evals: STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS, eval_families: STAGE7_RELATION_OUTPUT_0_FAMILIES, local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.family" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ From 993e8bcc0a62dab05e486f4398bff94c36ccf4d0 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 21:51:36 -0600 Subject: [PATCH 105/171] refactor(bolt): lower hamming output weighted Lower Stage 7 hamming-weight relation output into a compact weighted-sum field expression and remove generated/runtime relation-output eval-family execution. --- crates/bolt-verifier-runtime/src/lib.rs | 207 ++++++++++-------- .../jolt/emit/rust/relation_outputs.rs | 118 +--------- .../src/protocols/jolt/emit/rust/stage7.rs | 23 ++ .../src/protocols/jolt/rust_target_plan.rs | 127 ++++++++++- .../bolt/src/protocols/jolt/verifier_plan.rs | 6 +- .../jolt/verifier_relation_outputs.rs | 82 +++++++ crates/bolt/tests/commitment_ir.rs | 43 ++-- crates/jolt-equivalence/src/plan_adapters.rs | 88 ++++---- crates/jolt-verifier/src/stages/stage3.rs | 6 +- crates/jolt-verifier/src/stages/stage4.rs | 4 +- crates/jolt-verifier/src/stages/stage5.rs | 6 +- crates/jolt-verifier/src/stages/stage6.rs | 12 +- crates/jolt-verifier/src/stages/stage7.rs | 16 +- 13 files changed, 434 insertions(+), 304 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 075eab1345..5eb0aea5cc 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -251,6 +251,13 @@ pub enum FieldExprKind { Neg, Pow(usize), LagrangeBasisEval(i64, usize, usize), + EvalFamilyWeightedSum { + eval_count: usize, + power_stride: usize, + value_term_offsets: &'static [usize], + shared_term_offsets: &'static [usize], + item_term_offsets: &'static [usize], + }, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -388,34 +395,10 @@ pub struct StructuredPolynomialEvalRef { pub index: usize, } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct RelationOutputEvalFamilySharedTermPlan { - pub gamma_power_offset: usize, - pub factor: &'static str, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct RelationOutputEvalFamilyItemTermPlan { - pub gamma_power_offset: usize, - pub factors: &'static [&'static str], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct RelationOutputEvalFamilyPlan { - pub symbol: &'static str, - pub gamma: &'static str, - pub evals: &'static [&'static str], - pub power_stride: usize, - pub value_term_offsets: &'static [usize], - pub shared_terms: &'static [RelationOutputEvalFamilySharedTermPlan], - pub item_terms: &'static [RelationOutputEvalFamilyItemTermPlan], -} - #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: R, pub structured_polynomial_evals: &'static [StructuredPolynomialEvalRef], - pub eval_families: &'static [RelationOutputEvalFamilyPlan], pub local_scalars: &'static [&'static str], pub expected_output: &'static str, } @@ -1344,10 +1327,6 @@ pub fn evaluate_relation_output( let value = evaluate_structured_polynomial(polynomial_eval.polynomial, &x_point, y_point)?; scratch.insert(polynomial_eval.symbol, value); } - for family in plan.eval_families { - let value = evaluate_relation_output_eval_family(family, store, &scratch)?; - scratch.insert(family.symbol, value); - } evaluate_available_field_exprs_with_scratch(field_exprs, store, &mut scratch)?; scratch .scalar_or(store, plan.expected_output) @@ -1403,72 +1382,6 @@ fn relation_output_x_point_source<'a>( .ok_or(RuntimePlanError::MissingValue { symbol: source }) } -fn evaluate_relation_output_eval_family( - family: &RelationOutputEvalFamilyPlan, - store: &ValueStore, - scratch: &ScratchScalars, -) -> Result { - let gamma = scratch - .scalar_or(store, family.gamma) - .ok_or(RuntimePlanError::MissingValue { - symbol: family.gamma, - })?; - for term in family.item_terms { - require_operand_count(family.symbol, family.evals.len(), term.factors.len())?; - } - let value_offset_powers = family - .value_term_offsets - .iter() - .map(|&offset| pow_field(gamma, offset)) - .collect::>(); - let shared_terms = family - .shared_terms - .iter() - .map(|term| (term, pow_field(gamma, term.gamma_power_offset))) - .collect::>(); - let item_terms = family - .item_terms - .iter() - .map(|term| (term, pow_field(gamma, term.gamma_power_offset))) - .collect::>(); - let gamma_stride = pow_field(gamma, family.power_stride); - let mut gamma_base = Fr::from_u64(1); - - let mut result = Fr::from_u64(0); - for (index, eval_symbol) in family.evals.iter().enumerate() { - let eval = scratch - .scalar_or(store, eval_symbol) - .ok_or(RuntimePlanError::MissingValue { - symbol: eval_symbol, - })?; - let weighted_eval = eval * gamma_base; - for offset_power in &value_offset_powers { - result += weighted_eval * *offset_power; - } - for (term, offset_power) in &shared_terms { - let factor = - scratch - .scalar_or(store, term.factor) - .ok_or(RuntimePlanError::MissingValue { - symbol: term.factor, - })?; - result += weighted_eval * factor * *offset_power; - } - for (term, offset_power) in &item_terms { - let factor_symbol = term.factors[index]; - let factor = - scratch - .scalar_or(store, factor_symbol) - .ok_or(RuntimePlanError::MissingValue { - symbol: factor_symbol, - })?; - result += weighted_eval * factor * *offset_power; - } - gamma_base *= gamma_stride; - } - Ok(result) -} - fn evaluate_structured_polynomial_point( plan: StructuredPolynomialPointPlan, raw_point: &[Fr], @@ -1700,7 +1613,85 @@ pub fn evaluate_field_expr( actual: weights.len(), }) } + FieldExprKind::EvalFamilyWeightedSum { + eval_count, + power_stride, + value_term_offsets, + shared_term_offsets, + item_term_offsets, + } => evaluate_eval_family_weighted_sum( + expr.symbol, + operands, + eval_count, + power_stride, + value_term_offsets, + shared_term_offsets, + item_term_offsets, + ), + } +} + +fn evaluate_eval_family_weighted_sum( + symbol: &'static str, + operands: &[F], + eval_count: usize, + power_stride: usize, + value_term_offsets: &[usize], + shared_term_offsets: &[usize], + item_term_offsets: &[usize], +) -> Result { + let term_count = value_term_offsets.len() + shared_term_offsets.len() + item_term_offsets.len(); + if eval_count == 0 || term_count == 0 { + return Err(RuntimePlanError::InvalidInputLength { + input: symbol, + expected: 1, + actual: 0, + }); + } + let expected_operands = + 1 + eval_count + shared_term_offsets.len() + eval_count * item_term_offsets.len(); + require_operand_count(symbol, expected_operands, operands.len())?; + + let gamma = operands[0]; + let evals_start = 1; + let shared_start = evals_start + eval_count; + let item_start = shared_start + shared_term_offsets.len(); + let evals = &operands[evals_start..shared_start]; + let shared_factors = &operands[shared_start..item_start]; + let item_factors = &operands[item_start..]; + + let value_offset_powers = value_term_offsets + .iter() + .map(|&offset| pow_field(gamma, offset)) + .collect::>(); + let shared_terms = shared_term_offsets + .iter() + .zip(shared_factors.iter()) + .map(|(&offset, &factor)| (pow_field(gamma, offset), factor)) + .collect::>(); + let item_offset_powers = item_term_offsets + .iter() + .map(|&offset| pow_field(gamma, offset)) + .collect::>(); + + let gamma_stride = pow_field(gamma, power_stride); + let mut gamma_base = F::from_u64(1); + let mut result = F::from_u64(0); + for (eval_index, &eval) in evals.iter().enumerate() { + let weighted_eval = eval * gamma_base; + for offset_power in &value_offset_powers { + result += weighted_eval * *offset_power; + } + for (offset_power, factor) in &shared_terms { + result += weighted_eval * *factor * *offset_power; + } + for (term_index, offset_power) in item_offset_powers.iter().enumerate() { + let factor = item_factors[term_index * eval_count + eval_index]; + result += weighted_eval * factor * *offset_power; + } + gamma_base *= gamma_stride; } + Ok(result) } pub fn field_powers(base: Fr, count: usize) -> Vec { @@ -1900,4 +1891,32 @@ mod tests { assert_eq!(store.try_scalar("family.ab.product"), Some(Fr::from_u64(6))); assert_eq!(store.try_scalar("family.ab.sum"), Some(Fr::from_u64(5))); } + + #[test] + fn field_expr_evaluates_eval_family_weighted_sum() { + let value = evaluate_field_expr( + &FieldExprPlan { + symbol: "family.weighted", + kind: FieldExprKind::EvalFamilyWeightedSum { + eval_count: 2, + power_stride: 3, + value_term_offsets: &[0], + shared_term_offsets: &[1], + item_term_offsets: &[2], + }, + operands: &["gamma", "eval.a", "eval.b", "shared.eq", "item.a", "item.b"], + }, + &[ + Fr::from_u64(2), + Fr::from_u64(3), + Fr::from_u64(5), + Fr::from_u64(7), + Fr::from_u64(11), + Fr::from_u64(13), + ], + ) + .unwrap(); + + assert_eq!(value, Fr::from_u64(2857)); + } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index 71bde15b29..7bd06678ec 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -16,6 +16,12 @@ pub fn emit_verifier_relation_output_constants( emit_relation_output_value_constants(&mut source, stage_type, relation_output_values)?; let mut claims = Vec::new(); for (index, claim) in relation_outputs.iter().enumerate() { + if let Some(family) = claim.eval_families.first() { + return Err(EmitError::new(format!( + "{stage_type} relation output eval family @{} must be lowered before Rust verifier emission", + family.symbol + ))); + } if let Some(family) = claim.product_families.first() { return Err(EmitError::new(format!( "{stage_type} relation output product family @{} must be lowered before Rust verifier emission", @@ -31,10 +37,9 @@ pub fn emit_verifier_relation_output_constants( &values_name, &claim.structured_polynomial_evals, ); - let eval_families = emit_eval_family_constants(&mut source, stage_type, index, claim); let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim); claims.push(format!( - " {stage_type}RelationOutputPlan {{ relation: {}, structured_polynomial_evals: {values}, eval_families: {eval_families}, local_scalars: {local_scalars}, expected_output: {} }},", + " {stage_type}RelationOutputPlan {{ relation: {}, structured_polynomial_evals: {values}, local_scalars: {local_scalars}, expected_output: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, rust_str(&claim.expected_output) )); @@ -99,83 +104,6 @@ fn emit_local_scalar_constants( name } -fn emit_eval_family_constants( - source: &mut String, - stage_type: &str, - claim_index: usize, - claim: &RelationOutputPlan, -) -> String { - if claim.eval_families.is_empty() { - return "&[]".to_owned(); - } - let upper_stage = stage_type.to_ascii_uppercase(); - let mut family_rows = Vec::new(); - for (family_index, family) in claim.eval_families.iter().enumerate() { - let prefix = format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_FAMILY_{family_index}"); - let evals_name = format!("{prefix}_EVALS"); - let evals = rust_str_array(&family.evals); - push_format( - source, - format_args!("pub const {evals_name}: &[&str] = &[{evals}];\n"), - ); - let value_offsets_name = format!("{prefix}_VALUE_TERM_OFFSETS"); - let value_offsets = - emit_usize_slice_or_inline(source, &value_offsets_name, &family.value_term_offsets); - let shared_terms_name = format!("{prefix}_SHARED_TERMS"); - let shared_terms = family - .shared_terms - .iter() - .map(|term| { - format!( - " bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan {{ gamma_power_offset: {}, factor: {} }},", - term.gamma_power_offset, - rust_str(&term.factor) - ) - }) - .collect::>() - .join("\n"); - push_format( - source, - format_args!( - "pub const {shared_terms_name}: &[bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan] = &[\n{shared_terms}\n];\n" - ), - ); - - let mut item_rows = Vec::new(); - for (term_index, term) in family.item_terms.iter().enumerate() { - let factors_name = format!("{prefix}_ITEM_TERM_{term_index}_FACTORS"); - let factors = emit_str_slice_or_inline(source, &factors_name, &term.factors); - item_rows.push(format!( - " bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan {{ gamma_power_offset: {}, factors: {factors} }},", - term.gamma_power_offset - )); - } - let item_terms_name = format!("{prefix}_ITEM_TERMS"); - let item_terms = item_rows.join("\n"); - push_format( - source, - format_args!( - "pub const {item_terms_name}: &[bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan] = &[\n{item_terms}\n];\n" - ), - ); - family_rows.push(format!( - " bolt_verifier_runtime::RelationOutputEvalFamilyPlan {{ symbol: {}, gamma: {}, evals: {evals_name}, power_stride: {}, value_term_offsets: {value_offsets}, shared_terms: {shared_terms_name}, item_terms: {item_terms_name} }},", - rust_str(&family.symbol), - rust_str(&family.gamma), - family.power_stride - )); - } - let families_name = format!("{upper_stage}_RELATION_OUTPUT_{claim_index}_FAMILIES"); - let families = family_rows.join("\n"); - push_format( - source, - format_args!( - "pub const {families_name}: &[bolt_verifier_runtime::RelationOutputEvalFamilyPlan] = &[\n{families}\n];\n\n" - ), - ); - families_name -} - fn emit_structured_polynomial_eval_refs_slice_or_inline( source: &mut String, name: &str, @@ -210,30 +138,6 @@ fn structured_polynomial_eval_ref_expr(value: &StructuredPolynomialEvalRefPlan) ) } -fn emit_str_slice_or_inline(source: &mut String, name: &str, values: &[String]) -> String { - if values.len() <= 4 { - return format!("&[{}]", rust_str_array(values)); - } - let values = rust_str_array(values); - push_format( - source, - format_args!("pub const {name}: &[&str] = &[{values}];\n"), - ); - name.to_owned() -} - -fn emit_usize_slice_or_inline(source: &mut String, name: &str, values: &[usize]) -> String { - if values.len() <= 4 { - return format!("&[{}]", usize_array(values)); - } - let values = usize_array(values); - push_format( - source, - format_args!("pub const {name}: &[usize] = &[{values}];\n"), - ); - name.to_owned() -} - fn structured_polynomial_kind_expr( stage_type: &str, polynomial: StructuredPolynomialKind, @@ -305,11 +209,3 @@ fn rust_str_array(values: &[String]) -> String { .collect::>() .join(", ") } - -fn usize_array(values: &[usize]) -> String { - values - .iter() - .map(ToString::to_string) - .collect::>() - .join(", ") -} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 2a29f620c7..ca1b0152d8 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -17,6 +17,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ parse_output_product_family_plan, FieldExprDependencies, RelationOutputAst as Stage7RelationOutputAst, RelationOutputEvalFamilyPlan as Stage7RelationOutputEvalFamilyPlan, + RelationOutputFieldExprPlan as Stage7RelationOutputFieldExprPlan, RelationOutputFunctionFamilyPlan as Stage7RelationOutputFunctionFamilyPlan, RelationOutputPlan as Stage7RelationOutputPlan, RelationOutputProductFamilyPlan as Stage7RelationOutputProductFamilyPlan, @@ -143,6 +144,16 @@ impl FieldExprDependencies for Stage7FieldExprPlan { } } +fn stage7_relation_output_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage7FieldExprPlan { + Stage7FieldExprPlan { + symbol: expr.symbol, + kind: "op".to_owned(), + formula: expr.formula, + operand_names: expr.operands.clone(), + operands: expr.operands, + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage7SumcheckClaimPlan { pub symbol: String, @@ -639,6 +650,18 @@ impl Stage7CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; + if is_verifier { + field_exprs.extend( + verifier_relation_outputs::lower_eval_family_output_to_weighted_sum( + "stage7", + "jolt.stage7.hamming_weight_claim_reduction", + &mut relation_output_eval_families, + &mut relation_output_asts, + )? + .into_iter() + .map(stage7_relation_output_expr), + ); + } if role == Role::Prover { verifier_relation_outputs::prune_output_only_field_exprs( &mut field_exprs, diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index 92a05e9944..426ac7b343 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -248,7 +248,7 @@ impl JoltVerifierRelationKind { } } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[derive(Clone, Debug, PartialEq, Eq)] pub(crate) enum FieldExprKind { OpeningEval, Add, @@ -265,6 +265,13 @@ pub(crate) enum FieldExprKind { domain_size: usize, index: usize, }, + EvalFamilyWeightedSum { + eval_count: usize, + power_stride: usize, + value_term_offsets: Vec, + shared_term_offsets: Vec, + item_term_offsets: Vec, + }, } impl FieldExprKind { @@ -281,6 +288,9 @@ impl FieldExprKind { "field.neg" => Ok(Self::Neg), value if value.starts_with("field.pow:") => parse_pow(value), value if value.starts_with("poly.lagrange_basis_eval:") => parse_lagrange(value), + value if value.starts_with("eval_family.weighted_sum:") => { + parse_eval_family_weighted_sum(value) + } _ => Err(RustTargetPlanError::unsupported( "field expression formula", value, @@ -288,7 +298,7 @@ impl FieldExprKind { } } - pub(crate) fn rust_variant_expr(self) -> String { + pub(crate) fn rust_variant_expr(&self) -> String { match self { Self::OpeningEval => "OpeningEval".to_owned(), Self::Add => "Add".to_owned(), @@ -305,6 +315,18 @@ impl FieldExprKind { domain_size, index, } => format!("LagrangeBasisEval({domain_start}, {domain_size}, {index})"), + Self::EvalFamilyWeightedSum { + eval_count, + power_stride, + value_term_offsets, + shared_term_offsets, + item_term_offsets, + } => format!( + "EvalFamilyWeightedSum {{ eval_count: {eval_count}, power_stride: {power_stride}, value_term_offsets: {}, shared_term_offsets: {}, item_term_offsets: {} }}", + usize_slice_expr(value_term_offsets), + usize_slice_expr(shared_term_offsets), + usize_slice_expr(item_term_offsets), + ), } } } @@ -390,6 +412,85 @@ fn parse_lagrange(value: &str) -> Result { }) } +fn parse_eval_family_weighted_sum(value: &str) -> Result { + let spec = value + .strip_prefix("eval_family.weighted_sum:") + .ok_or_else(|| RustTargetPlanError::unsupported("field expression formula", value))?; + let parts = spec.split(':').collect::>(); + let [eval_count, power_stride, value_offsets, shared_offsets, item_offsets] = parts.as_slice() + else { + return Err(RustTargetPlanError::unsupported( + "field expression formula", + value, + )); + }; + let eval_count = eval_count + .parse::() + .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; + let power_stride = power_stride + .parse::() + .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; + Ok(FieldExprKind::EvalFamilyWeightedSum { + eval_count, + power_stride, + value_term_offsets: parse_usize_list(value_offsets, value)?, + shared_term_offsets: parse_usize_list(shared_offsets, value)?, + item_term_offsets: parse_usize_list(item_offsets, value)?, + }) +} + +pub(crate) fn eval_family_weighted_sum_formula( + eval_count: usize, + power_stride: usize, + value_term_offsets: &[usize], + shared_term_offsets: &[usize], + item_term_offsets: &[usize], +) -> String { + format!( + "eval_family.weighted_sum:{eval_count}:{power_stride}:{}:{}:{}", + join_usize_list(value_term_offsets), + join_usize_list(shared_term_offsets), + join_usize_list(item_term_offsets), + ) +} + +fn parse_usize_list(value: &str, full_formula: &str) -> Result, RustTargetPlanError> { + if value == "_" { + return Ok(Vec::new()); + } + value + .split(',') + .map(|part| { + part.parse::().map_err(|_| { + RustTargetPlanError::unsupported("field expression formula", full_formula) + }) + }) + .collect() +} + +fn join_usize_list(values: &[usize]) -> String { + if values.is_empty() { + return "_".to_owned(); + } + values + .iter() + .map(usize::to_string) + .collect::>() + .join(",") +} + +fn usize_slice_expr(values: &[usize]) -> String { + if values.is_empty() { + return "&[]".to_owned(); + } + let values = values + .iter() + .map(usize::to_string) + .collect::>() + .join(", "); + format!("&[{values}]") +} + #[cfg(test)] mod tests { use super::{ @@ -455,8 +556,19 @@ mod tests { index: 2, }) ); + assert_eq!( + FieldExprKind::from_cpu_attr("eval_family.weighted_sum:39:3:0:1:2").ok(), + Some(FieldExprKind::EvalFamilyWeightedSum { + eval_count: 39, + power_stride: 3, + value_term_offsets: vec![0], + shared_term_offsets: vec![1], + item_term_offsets: vec![2], + }) + ); assert!(FieldExprKind::from_cpu_attr("field.pow:nope").is_err()); assert!(FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:1:2").is_err()); + assert!(FieldExprKind::from_cpu_attr("eval_family.weighted_sum:1:2:0").is_err()); } #[test] @@ -474,5 +586,16 @@ mod tests { .rust_variant_expr(), "LagrangeBasisEval(-1, 3, 0)" ); + assert_eq!( + FieldExprKind::EvalFamilyWeightedSum { + eval_count: 39, + power_stride: 3, + value_term_offsets: vec![0], + shared_term_offsets: vec![1], + item_term_offsets: vec![2], + } + .rust_variant_expr(), + "EvalFamilyWeightedSum { eval_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], item_term_offsets: &[2] }" + ); } } diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 528101db96..ca49bec254 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -1203,7 +1203,7 @@ pub(crate) fn claim_kind_expr(stage_type_prefix: &str, kind: ClaimKind) -> Strin format!("{stage_type_prefix}ClaimKind::{}", kind.rust_variant()) } -pub(crate) fn field_expr_kind_expr(stage_type_prefix: &str, kind: FieldExprKind) -> String { +pub(crate) fn field_expr_kind_expr(stage_type_prefix: &str, kind: &FieldExprKind) -> String { format!( "{stage_type_prefix}FieldExprKind::{}", kind.rust_variant_expr() @@ -1330,7 +1330,7 @@ pub(crate) fn emit_field_expr_constants( format!( " {stage_type_prefix}FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", rust_str(&expr.symbol), - field_expr_kind_expr(stage_type_prefix, expr.kind), + field_expr_kind_expr(stage_type_prefix, &expr.kind), rust_str_slice_expr(&expr.operands), ) }) @@ -1357,7 +1357,7 @@ pub(crate) fn emit_field_expr_constants_chunked( format!( "{helper_name}({}, {}, {})", rust_str(&expr.symbol), - field_expr_kind_expr(stage_type_prefix, expr.kind), + field_expr_kind_expr(stage_type_prefix, &expr.kind), rust_str_slice_expr(&expr.operands) ) }) diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index b4d5e30003..dad57aae62 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -5,6 +5,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::EmitError; use crate::ir::string_attribute_value; +use crate::protocols::jolt::rust_target_plan::eval_family_weighted_sum_formula; use crate::protocols::jolt::verifier_values::{VerifierPointSourceSet, VerifierScalarSourceSet}; use crate::schema::operation_name; @@ -737,6 +738,87 @@ pub fn lower_eval_family_output( Ok(rows) } +pub fn lower_eval_family_output_to_weighted_sum( + stage: &str, + relation: &str, + relation_output_eval_families: &mut Vec, + relation_output_asts: &mut [RelationOutputAst], +) -> Result, EmitError> { + let Some(claim) = relation_output_asts + .iter_mut() + .find(|claim| claim.relation == relation) + else { + return Ok(Vec::new()); + }; + let family_symbol = claim.expected_output.clone(); + let family_index = relation_output_eval_families + .iter() + .position(|family| family.symbol == family_symbol) + .ok_or_else(|| { + EmitError::new(format!( + "{stage} relation output for @{relation} references missing eval family @{family_symbol}" + )) + })?; + let family = relation_output_eval_families[family_index].clone(); + if family.evals.is_empty() { + return Err(EmitError::new(format!( + "{stage} relation output eval family @{family_symbol} has no eval terms" + ))); + } + let term_count = + family.value_term_offsets.len() + family.shared_terms.len() + family.item_terms.len(); + if term_count == 0 { + return Err(EmitError::new(format!( + "{stage} relation output eval family @{family_symbol} has no scalar terms" + ))); + } + for term in &family.item_terms { + verify_count( + "relation output eval family item factors", + &family.symbol, + family.evals.len(), + term.factors.len(), + )?; + } + + let prefix = relation_output_family_prefix(&family.symbol); + let claim_expr = format!("{prefix}.claim_expr"); + let mut operands = Vec::with_capacity( + 1 + family.evals.len() + + family.shared_terms.len() + + family.evals.len() * family.item_terms.len(), + ); + operands.push(family.gamma.clone()); + operands.extend(family.evals.iter().cloned()); + operands.extend(family.shared_terms.iter().map(|term| term.factor.clone())); + operands.extend( + family + .item_terms + .iter() + .flat_map(|term| term.factors.iter().cloned()), + ); + let formula = eval_family_weighted_sum_formula( + family.evals.len(), + family.power_stride, + &family.value_term_offsets, + &family + .shared_terms + .iter() + .map(|term| term.gamma_power_offset) + .collect::>(), + &family + .item_terms + .iter() + .map(|term| term.gamma_power_offset) + .collect::>(), + ); + claim.expected_output.clone_from(&claim_expr); + let _removed_family = relation_output_eval_families.remove(family_index); + Ok(vec![relation_output_field_expr( + claim_expr, &formula, operands, + )]) +} + pub fn lower_product_family_output( stage: &str, relation: &str, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 593e6cfdd6..a89e7bc977 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -2064,32 +2064,32 @@ fn stage7_rust_targets_extract_and_compile() { assert_eq!(prover_program.relation_output_values.len(), total_ra + 1); assert!(prover_program.relation_outputs.is_empty()); assert_eq!(verifier_program.relation_output_values.len(), total_ra + 1); - assert_eq!(verifier_program.relation_output_eval_families.len(), 1); + assert!(verifier_program.relation_output_eval_families.is_empty()); assert_eq!(verifier_program.relation_outputs.len(), 1); - let output_family = &verifier_program.relation_output_eval_families[0]; + assert!(verifier_program.relation_outputs[0] + .eval_families + .is_empty()); assert_eq!( - output_family.symbol, - "stage7.hamming_weight_claim_reduction.output.family" + verifier_program.relation_outputs[0].expected_output, + "stage7.hamming_weight_claim_reduction.output.claim_expr" ); + let output_expr = verifier_program + .field_exprs + .iter() + .find(|expr| expr.symbol == "stage7.hamming_weight_claim_reduction.output.claim_expr") + .expect("stage7 hamming output is lowered to a field expression"); assert_eq!( - output_family.gamma, - "stage7.hamming_weight_claim_reduction.gamma" + output_expr.formula, + format!("eval_family.weighted_sum:{total_ra}:3:0:1:2") ); - assert_eq!(output_family.evals.len(), total_ra); - assert_eq!(output_family.power_stride, 3); - assert_eq!(output_family.value_term_offsets, vec![0]); - assert_eq!(output_family.shared_terms.len(), 1); - assert_eq!(output_family.shared_terms[0].gamma_power_offset, 1); + assert_eq!(output_expr.operands.len(), 2 * total_ra + 2); assert_eq!( - output_family.shared_terms[0].factor, - "stage7.hamming_weight_claim_reduction.output.eq.Booleanity" + output_expr.operands[0], + "stage7.hamming_weight_claim_reduction.gamma" ); - assert_eq!(output_family.item_terms.len(), 1); - assert_eq!(output_family.item_terms[0].gamma_power_offset, 2); - assert_eq!(output_family.item_terms[0].factors.len(), total_ra); assert_eq!( - verifier_program.relation_outputs[0].eval_families, - vec![output_family.clone()] + output_expr.operands[1 + total_ra], + "stage7.hamming_weight_claim_reduction.output.eq.Booleanity" ); assert!(prover_program.point_zeros.is_empty()); assert_eq!(prover_program.point_slices.len(), 1); @@ -2140,12 +2140,15 @@ fn stage7_rust_targets_extract_and_compile() { .source .contains("expected_hamming_weight_claim_reduction")); assert!(verifier_source.source.contains("Stage7RelationOutputPlan")); - assert!(verifier_source + assert!(!verifier_source .source .contains("RelationOutputEvalFamilyPlan")); - assert!(verifier_source + assert!(!verifier_source .source .contains("STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS")); + assert!(verifier_source + .source + .contains("Stage7FieldExprKind::EvalFamilyWeightedSum")); assert!(verifier_source .source .contains("stage7.hamming_weight_claim_reduction.output.eq.Booleanity")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index afdae7d758..6f87f4131c 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -268,6 +268,10 @@ fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKin "field.add" => bolt_verifier_runtime::FieldExprKind::Add, "field.sub" => bolt_verifier_runtime::FieldExprKind::Sub, "field.mul" => bolt_verifier_runtime::FieldExprKind::Mul, + "field.sum" => bolt_verifier_runtime::FieldExprKind::Sum, + "field.product" => bolt_verifier_runtime::FieldExprKind::Product, + "field_vector.sum" => bolt_verifier_runtime::FieldExprKind::FieldVectorSum, + "field_vector.product" => bolt_verifier_runtime::FieldExprKind::FieldVectorProduct, "field.neg" => bolt_verifier_runtime::FieldExprKind::Neg, value if value.starts_with("field.pow:") => { let exponent = value @@ -293,10 +297,48 @@ fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKin parts[2].parse::().expect("lagrange index is usize"), ) } + value if value.starts_with("eval_family.weighted_sum:") => { + let spec = value + .strip_prefix("eval_family.weighted_sum:") + .expect("weighted eval-family expression has prefix"); + let parts = spec.split(':').collect::>(); + assert!( + parts.len() == 5, + "weighted eval-family expression has five fields" + ); + bolt_verifier_runtime::FieldExprKind::EvalFamilyWeightedSum { + eval_count: parts[0] + .parse::() + .expect("weighted eval-family eval count is usize"), + power_stride: parts[1] + .parse::() + .expect("weighted eval-family power stride is usize"), + value_term_offsets: leak_slice(parse_usize_list(parts[2])), + shared_term_offsets: leak_slice(parse_usize_list(parts[3])), + item_term_offsets: leak_slice(parse_usize_list(parts[4])), + } + } value => panic!("unsupported generated field expression kind `{value}`"), } } +#[expect( + clippy::expect_used, + reason = "equivalence adapters fail fast when a compiler weighted-sum field expression is malformed" +)] +fn parse_usize_list(value: &str) -> Vec { + if value == "_" { + return Vec::new(); + } + value + .split(',') + .map(|part| { + part.parse::() + .expect("weighted eval-family offset is usize") + }) + .collect() +} + #[expect( clippy::panic, reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier enum tag" @@ -643,52 +685,6 @@ macro_rules! define_stage_adapter_impl { }) .collect(), ), - eval_families: super::leak_slice( - plan.eval_families - .iter() - .map(|family| bolt_verifier_runtime::RelationOutputEvalFamilyPlan { - symbol: super::leak_str(&family.symbol), - gamma: super::leak_str(&family.gamma), - evals: super::leak_slice( - family - .evals - .iter() - .map(|symbol| super::leak_str(symbol)) - .collect(), - ), - power_stride: family.power_stride, - value_term_offsets: super::leak_slice( - family.value_term_offsets.clone(), - ), - shared_terms: super::leak_slice( - family - .shared_terms - .iter() - .map(|term| bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan { - gamma_power_offset: term.gamma_power_offset, - factor: super::leak_str(&term.factor), - }) - .collect(), - ), - item_terms: super::leak_slice( - family - .item_terms - .iter() - .map(|term| bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan { - gamma_power_offset: term.gamma_power_offset, - factors: super::leak_slice( - term - .factors - .iter() - .map(|symbol| super::leak_str(symbol)) - .collect(), - ), - }) - .collect(), - ), - }) - .collect(), - ), local_scalars: super::leak_str_slice(&plan.local_scalars), expected_output: super::leak_str(&plan.expected_output), }) diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index e30c0962d2..239c7f7c46 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -218,9 +218,9 @@ pub const STAGE3_RELATION_OUTPUT_VALUES: &[Stage3StructuredPolynomialEvalPlan] = ]; pub const STAGE3_RELATION_OUTPUTS: &[Stage3RelationOutputPlan] = &[ - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextPC", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", index: 1 }], eval_families: &[], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", index: 2 }], eval_families: &[], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.registers.output.eq.RdWriteValue", index: 3 }], eval_families: &[], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextPC", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", index: 1 }], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", index: 2 }], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.registers.output.eq.RdWriteValue", index: 3 }], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index a45220abc8..29d018f70b 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -180,8 +180,8 @@ pub const STAGE4_RELATION_OUTPUT_VALUES: &[Stage4StructuredPolynomialEvalPlan] = ]; pub const STAGE4_RELATION_OUTPUTS: &[Stage4RelationOutputPlan] = &[ - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", index: 0 }], eval_families: &[], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.ram_val_check.output.lt.RamValCycle", index: 1 }], eval_families: &[], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", index: 0 }], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.ram_val_check.output.lt.RamValCycle", index: 1 }], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index ad0b271d8b..a6eff0991a 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -412,9 +412,9 @@ pub const STAGE5_RELATION_OUTPUT_VALUES: &[Stage5StructuredPolynomialEvalPlan] = pub const STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; pub const STAGE5_RELATION_OUTPUTS: &[Stage5RelationOutputPlan] = &[ - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", index: 1 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", index: 2 }], eval_families: &[], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", index: 3 }], eval_families: &[], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", index: 4 }], eval_families: &[], local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", index: 1 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", index: 2 }], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", index: 3 }], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", index: 4 }], local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 68e0ad94f3..98ba61d1d5 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -669,12 +669,12 @@ pub const STAGE6_RELATION_OUTPUT_VALUES: &[Stage6StructuredPolynomialEvalPlan] = pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], eval_families: &[], local_scalars: &[], expected_output: "stage6.booleanity.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], eval_families: &[], local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], eval_families: &[], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], eval_families: &[], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], eval_families: &[], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], eval_families: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], local_scalars: &[], expected_output: "stage6.booleanity.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 671e6ec79e..7ab55dcb33 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -210,7 +210,7 @@ pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[ stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial88", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial87", "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial89", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial88", "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial90", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial89", "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial91", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial90", "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial92", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial91", "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial93", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial92", "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial94", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial93", "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial95", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial94", "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial96", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial95", "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial97", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial96", "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial98", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial97", "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial99", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial98", "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial100", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial99", "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial101", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial100", "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial102", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial101", "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial103", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial102", "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial104", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial103", "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial105", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial104", "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial106", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial105", "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial107", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial106", "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial108", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial107", "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial109", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial108", "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial110", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial109", "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial111", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial110", "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr", Stage7FieldExprKind::EvalFamilyWeightedSum { eval_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], item_term_offsets: &[2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), ]; pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ @@ -314,20 +314,8 @@ pub const STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS: &[bolt_verifier_ bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", index: 38 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", index: 39 }, ]; -pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS: &[&str] = &["stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3"]; -pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_SHARED_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan] = &[ - bolt_verifier_runtime::RelationOutputEvalFamilySharedTermPlan { gamma_power_offset: 1, factor: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity" }, -]; -pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_ITEM_TERM_0_FACTORS: &[&str] = &["stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]; -pub const STAGE7_RELATION_OUTPUT_0_FAMILY_0_ITEM_TERMS: &[bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan] = &[ - bolt_verifier_runtime::RelationOutputEvalFamilyItemTermPlan { gamma_power_offset: 2, factors: STAGE7_RELATION_OUTPUT_0_FAMILY_0_ITEM_TERM_0_FACTORS }, -]; -pub const STAGE7_RELATION_OUTPUT_0_FAMILIES: &[bolt_verifier_runtime::RelationOutputEvalFamilyPlan] = &[ - bolt_verifier_runtime::RelationOutputEvalFamilyPlan { symbol: "stage7.hamming_weight_claim_reduction.output.family", gamma: "stage7.hamming_weight_claim_reduction.gamma", evals: STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS, power_stride: 3, value_term_offsets: &[0], shared_terms: STAGE7_RELATION_OUTPUT_0_FAMILY_0_SHARED_TERMS, item_terms: STAGE7_RELATION_OUTPUT_0_FAMILY_0_ITEM_TERMS }, -]; - pub const STAGE7_RELATION_OUTPUTS: &[Stage7RelationOutputPlan] = &[ - Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, structured_polynomial_evals: STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS, eval_families: STAGE7_RELATION_OUTPUT_0_FAMILIES, local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.family" }, + Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, structured_polynomial_evals: STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS, local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.claim_expr" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ From 7d5482574361c127ae37d6686e0196193efe0e56 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 22:04:39 -0600 Subject: [PATCH 106/171] refactor(bolt): compact hamming input claim Replace Stage 7 verifier input-claim gamma expansion with a compact power-strided weighted row and rename the weighted field expression to describe its generic layout. --- crates/bolt-verifier-runtime/src/lib.rs | 48 +++---- .../src/protocols/jolt/emit/rust/stage7.rs | 129 ++++++++++++++++++ .../src/protocols/jolt/rust_target_plan.rs | 62 ++++----- .../jolt/verifier_relation_outputs.rs | 4 +- crates/bolt/tests/commitment_ir.rs | 26 +++- crates/jolt-equivalence/src/plan_adapters.rs | 20 +-- crates/jolt-verifier/src/stages/stage7.rs | 47 +------ 7 files changed, 222 insertions(+), 114 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 5eb0aea5cc..2a55ec139a 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -251,12 +251,12 @@ pub enum FieldExprKind { Neg, Pow(usize), LagrangeBasisEval(i64, usize, usize), - EvalFamilyWeightedSum { - eval_count: usize, + PowerStridedWeightedSum { + row_count: usize, power_stride: usize, value_term_offsets: &'static [usize], shared_term_offsets: &'static [usize], - item_term_offsets: &'static [usize], + row_term_offsets: &'static [usize], }, } @@ -1613,35 +1613,35 @@ pub fn evaluate_field_expr( actual: weights.len(), }) } - FieldExprKind::EvalFamilyWeightedSum { - eval_count, + FieldExprKind::PowerStridedWeightedSum { + row_count, power_stride, value_term_offsets, shared_term_offsets, - item_term_offsets, - } => evaluate_eval_family_weighted_sum( + row_term_offsets, + } => evaluate_power_strided_weighted_sum( expr.symbol, operands, - eval_count, + row_count, power_stride, value_term_offsets, shared_term_offsets, - item_term_offsets, + row_term_offsets, ), } } -fn evaluate_eval_family_weighted_sum( +fn evaluate_power_strided_weighted_sum( symbol: &'static str, operands: &[F], - eval_count: usize, + row_count: usize, power_stride: usize, value_term_offsets: &[usize], shared_term_offsets: &[usize], - item_term_offsets: &[usize], + row_term_offsets: &[usize], ) -> Result { - let term_count = value_term_offsets.len() + shared_term_offsets.len() + item_term_offsets.len(); - if eval_count == 0 || term_count == 0 { + let term_count = value_term_offsets.len() + shared_term_offsets.len() + row_term_offsets.len(); + if row_count == 0 || term_count == 0 { return Err(RuntimePlanError::InvalidInputLength { input: symbol, expected: 1, @@ -1649,16 +1649,16 @@ fn evaluate_eval_family_weighted_sum( }); } let expected_operands = - 1 + eval_count + shared_term_offsets.len() + eval_count * item_term_offsets.len(); + 1 + row_count + shared_term_offsets.len() + row_count * row_term_offsets.len(); require_operand_count(symbol, expected_operands, operands.len())?; let gamma = operands[0]; let evals_start = 1; - let shared_start = evals_start + eval_count; + let shared_start = evals_start + row_count; let item_start = shared_start + shared_term_offsets.len(); let evals = &operands[evals_start..shared_start]; let shared_factors = &operands[shared_start..item_start]; - let item_factors = &operands[item_start..]; + let row_factors = &operands[item_start..]; let value_offset_powers = value_term_offsets .iter() @@ -1669,7 +1669,7 @@ fn evaluate_eval_family_weighted_sum( .zip(shared_factors.iter()) .map(|(&offset, &factor)| (pow_field(gamma, offset), factor)) .collect::>(); - let item_offset_powers = item_term_offsets + let row_offset_powers = row_term_offsets .iter() .map(|&offset| pow_field(gamma, offset)) .collect::>(); @@ -1685,8 +1685,8 @@ fn evaluate_eval_family_weighted_sum( for (offset_power, factor) in &shared_terms { result += weighted_eval * *factor * *offset_power; } - for (term_index, offset_power) in item_offset_powers.iter().enumerate() { - let factor = item_factors[term_index * eval_count + eval_index]; + for (term_index, offset_power) in row_offset_powers.iter().enumerate() { + let factor = row_factors[term_index * row_count + eval_index]; result += weighted_eval * factor * *offset_power; } gamma_base *= gamma_stride; @@ -1893,16 +1893,16 @@ mod tests { } #[test] - fn field_expr_evaluates_eval_family_weighted_sum() { + fn field_expr_evaluates_power_strided_weighted_sum() { let value = evaluate_field_expr( &FieldExprPlan { symbol: "family.weighted", - kind: FieldExprKind::EvalFamilyWeightedSum { - eval_count: 2, + kind: FieldExprKind::PowerStridedWeightedSum { + row_count: 2, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], - item_term_offsets: &[2], + row_term_offsets: &[2], }, operands: &["gamma", "eval.a", "eval.b", "shared.eq", "item.a", "item.b"], }, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index ca1b0152d8..690ed022f7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -11,6 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::rust_target_plan::power_strided_weighted_sum_formula; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, @@ -154,6 +155,133 @@ fn stage7_relation_output_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage } } +struct HammingWeightClaimRow { + hamming_factor: String, + booleanity: String, + virtualization: String, +} + +fn compact_hamming_weight_input_claim( + field_exprs: &mut Vec, + claims: &mut [Stage7SumcheckClaimPlan], + opening_inputs: &[Stage7OpeningInputPlan], +) -> Result<(), EmitError> { + let Some(claim) = claims + .iter_mut() + .find(|claim| claim.symbol == "stage7.hamming_weight_claim_reduction.input") + else { + return Ok(()); + }; + let compact_symbol = "stage7.hamming_weight_claim_reduction.input.claim_expr"; + if claim.claim_value == compact_symbol { + return Ok(()); + } + if !claim + .claim_value + .starts_with("stage7.hamming_weight_claim_reduction.claim_expr") + { + return Err(EmitError::new(format!( + "stage7 hamming-weight input claim has unsupported claim value @{}", + claim.claim_value + ))); + } + + let rows = hamming_weight_claim_rows(opening_inputs)?; + let row_count = rows.len(); + let mut operands = Vec::with_capacity(1 + row_count + 3 * row_count); + operands.push("stage7.hamming_weight_claim_reduction.gamma".to_owned()); + operands.extend((0..row_count).map(|_| "stage7.field.one".to_owned())); + operands.extend(rows.iter().map(|row| row.hamming_factor.clone())); + operands.extend(rows.iter().map(|row| row.booleanity.clone())); + operands.extend(rows.iter().map(|row| row.virtualization.clone())); + + field_exprs.retain(|expr| !is_hamming_weight_input_claim_expr(&expr.symbol)); + field_exprs.push(Stage7FieldExprPlan { + symbol: compact_symbol.to_owned(), + kind: "op".to_owned(), + formula: power_strided_weighted_sum_formula(row_count, 3, &[], &[], &[0, 1, 2]), + operand_names: operands.clone(), + operands, + }); + compact_symbol.clone_into(&mut claim.claim_value); + Ok(()) +} + +fn hamming_weight_claim_rows( + opening_inputs: &[Stage7OpeningInputPlan], +) -> Result, EmitError> { + const HAMMING_INPUT: &str = "stage7.input.stage6.hamming_booleanity.HammingWeight"; + const BOOLEANITY_PREFIX: &str = "stage7.input.stage6.booleanity."; + let hamming_factor = opening_inputs + .iter() + .find(|input| input.symbol == HAMMING_INPUT) + .map(|input| input.symbol.clone()) + .ok_or_else(|| EmitError::new("stage7 hamming-weight input is missing"))?; + let mut rows = Vec::new(); + let mut inputs = opening_inputs + .iter() + .filter(|input| input.symbol != HAMMING_INPUT); + while let Some(booleanity) = inputs.next() { + let oracle = booleanity + .symbol + .strip_prefix(BOOLEANITY_PREFIX) + .ok_or_else(|| { + EmitError::new(format!( + "stage7 hamming-weight claim expected booleanity input, found @{}", + booleanity.symbol + )) + })?; + let virtualization = inputs.next().ok_or_else(|| { + EmitError::new(format!( + "stage7 hamming-weight claim missing virtualization input for @{oracle}" + )) + })?; + let (virtual_prefix, row_hamming_factor) = if oracle.starts_with("InstructionRa_") { + ( + "stage7.input.stage6.instruction_ra_virtual.", + "stage7.field.one".to_owned(), + ) + } else if oracle.starts_with("BytecodeRa_") { + ( + "stage7.input.stage6.bytecode_read_raf.", + "stage7.field.one".to_owned(), + ) + } else if oracle.starts_with("RamRa_") { + ( + "stage7.input.stage6.ram_ra_virtual.", + hamming_factor.clone(), + ) + } else { + return Err(EmitError::new(format!( + "stage7 hamming-weight claim has unsupported RA oracle @{oracle}" + ))); + }; + let expected_virtualization = format!("{virtual_prefix}{oracle}"); + if virtualization.symbol != expected_virtualization { + return Err(EmitError::new(format!( + "stage7 hamming-weight claim expected virtualization input @{expected_virtualization}, found @{}", + virtualization.symbol + ))); + } + rows.push(HammingWeightClaimRow { + hamming_factor: row_hamming_factor, + booleanity: booleanity.symbol.clone(), + virtualization: virtualization.symbol.clone(), + }); + } + if rows.is_empty() { + return Err(EmitError::new( + "stage7 hamming-weight claim has no RA input rows", + )); + } + Ok(rows) +} + +fn is_hamming_weight_input_claim_expr(symbol: &str) -> bool { + symbol.starts_with("stage7.hamming_weight_claim_reduction.claim.") + || symbol.starts_with("stage7.hamming_weight_claim_reduction.claim_expr") +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage7SumcheckClaimPlan { pub symbol: String, @@ -651,6 +779,7 @@ impl Stage7CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if is_verifier { + compact_hamming_weight_input_claim(&mut field_exprs, &mut claims, &opening_inputs)?; field_exprs.extend( verifier_relation_outputs::lower_eval_family_output_to_weighted_sum( "stage7", diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index 426ac7b343..b30da45b38 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -265,12 +265,12 @@ pub(crate) enum FieldExprKind { domain_size: usize, index: usize, }, - EvalFamilyWeightedSum { - eval_count: usize, + PowerStridedWeightedSum { + row_count: usize, power_stride: usize, value_term_offsets: Vec, shared_term_offsets: Vec, - item_term_offsets: Vec, + row_term_offsets: Vec, }, } @@ -288,8 +288,8 @@ impl FieldExprKind { "field.neg" => Ok(Self::Neg), value if value.starts_with("field.pow:") => parse_pow(value), value if value.starts_with("poly.lagrange_basis_eval:") => parse_lagrange(value), - value if value.starts_with("eval_family.weighted_sum:") => { - parse_eval_family_weighted_sum(value) + value if value.starts_with("field.power_strided_weighted_sum:") => { + parse_power_strided_weighted_sum(value) } _ => Err(RustTargetPlanError::unsupported( "field expression formula", @@ -315,17 +315,17 @@ impl FieldExprKind { domain_size, index, } => format!("LagrangeBasisEval({domain_start}, {domain_size}, {index})"), - Self::EvalFamilyWeightedSum { - eval_count, + Self::PowerStridedWeightedSum { + row_count, power_stride, value_term_offsets, shared_term_offsets, - item_term_offsets, + row_term_offsets, } => format!( - "EvalFamilyWeightedSum {{ eval_count: {eval_count}, power_stride: {power_stride}, value_term_offsets: {}, shared_term_offsets: {}, item_term_offsets: {} }}", + "PowerStridedWeightedSum {{ row_count: {row_count}, power_stride: {power_stride}, value_term_offsets: {}, shared_term_offsets: {}, row_term_offsets: {} }}", usize_slice_expr(value_term_offsets), usize_slice_expr(shared_term_offsets), - usize_slice_expr(item_term_offsets), + usize_slice_expr(row_term_offsets), ), } } @@ -412,45 +412,45 @@ fn parse_lagrange(value: &str) -> Result { }) } -fn parse_eval_family_weighted_sum(value: &str) -> Result { +fn parse_power_strided_weighted_sum(value: &str) -> Result { let spec = value - .strip_prefix("eval_family.weighted_sum:") + .strip_prefix("field.power_strided_weighted_sum:") .ok_or_else(|| RustTargetPlanError::unsupported("field expression formula", value))?; let parts = spec.split(':').collect::>(); - let [eval_count, power_stride, value_offsets, shared_offsets, item_offsets] = parts.as_slice() + let [row_count, power_stride, value_offsets, shared_offsets, row_offsets] = parts.as_slice() else { return Err(RustTargetPlanError::unsupported( "field expression formula", value, )); }; - let eval_count = eval_count + let row_count = row_count .parse::() .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; let power_stride = power_stride .parse::() .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; - Ok(FieldExprKind::EvalFamilyWeightedSum { - eval_count, + Ok(FieldExprKind::PowerStridedWeightedSum { + row_count, power_stride, value_term_offsets: parse_usize_list(value_offsets, value)?, shared_term_offsets: parse_usize_list(shared_offsets, value)?, - item_term_offsets: parse_usize_list(item_offsets, value)?, + row_term_offsets: parse_usize_list(row_offsets, value)?, }) } -pub(crate) fn eval_family_weighted_sum_formula( - eval_count: usize, +pub(crate) fn power_strided_weighted_sum_formula( + row_count: usize, power_stride: usize, value_term_offsets: &[usize], shared_term_offsets: &[usize], - item_term_offsets: &[usize], + row_term_offsets: &[usize], ) -> String { format!( - "eval_family.weighted_sum:{eval_count}:{power_stride}:{}:{}:{}", + "field.power_strided_weighted_sum:{row_count}:{power_stride}:{}:{}:{}", join_usize_list(value_term_offsets), join_usize_list(shared_term_offsets), - join_usize_list(item_term_offsets), + join_usize_list(row_term_offsets), ) } @@ -557,18 +557,18 @@ mod tests { }) ); assert_eq!( - FieldExprKind::from_cpu_attr("eval_family.weighted_sum:39:3:0:1:2").ok(), - Some(FieldExprKind::EvalFamilyWeightedSum { - eval_count: 39, + FieldExprKind::from_cpu_attr("field.power_strided_weighted_sum:39:3:0:1:2").ok(), + Some(FieldExprKind::PowerStridedWeightedSum { + row_count: 39, power_stride: 3, value_term_offsets: vec![0], shared_term_offsets: vec![1], - item_term_offsets: vec![2], + row_term_offsets: vec![2], }) ); assert!(FieldExprKind::from_cpu_attr("field.pow:nope").is_err()); assert!(FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:1:2").is_err()); - assert!(FieldExprKind::from_cpu_attr("eval_family.weighted_sum:1:2:0").is_err()); + assert!(FieldExprKind::from_cpu_attr("field.power_strided_weighted_sum:1:2:0").is_err()); } #[test] @@ -587,15 +587,15 @@ mod tests { "LagrangeBasisEval(-1, 3, 0)" ); assert_eq!( - FieldExprKind::EvalFamilyWeightedSum { - eval_count: 39, + FieldExprKind::PowerStridedWeightedSum { + row_count: 39, power_stride: 3, value_term_offsets: vec![0], shared_term_offsets: vec![1], - item_term_offsets: vec![2], + row_term_offsets: vec![2], } .rust_variant_expr(), - "EvalFamilyWeightedSum { eval_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], item_term_offsets: &[2] }" + "PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }" ); } } diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index dad57aae62..14fe44309d 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -5,7 +5,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::EmitError; use crate::ir::string_attribute_value; -use crate::protocols::jolt::rust_target_plan::eval_family_weighted_sum_formula; +use crate::protocols::jolt::rust_target_plan::power_strided_weighted_sum_formula; use crate::protocols::jolt::verifier_values::{VerifierPointSourceSet, VerifierScalarSourceSet}; use crate::schema::operation_name; @@ -797,7 +797,7 @@ pub fn lower_eval_family_output_to_weighted_sum( .iter() .flat_map(|term| term.factors.iter().cloned()), ); - let formula = eval_family_weighted_sum_formula( + let formula = power_strided_weighted_sum_formula( family.evals.len(), family.power_stride, &family.value_term_offsets, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index a89e7bc977..18e474a092 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -2073,6 +2073,25 @@ fn stage7_rust_targets_extract_and_compile() { verifier_program.relation_outputs[0].expected_output, "stage7.hamming_weight_claim_reduction.output.claim_expr" ); + let input_claim = verifier_program + .claims + .iter() + .find(|claim| claim.symbol == "stage7.hamming_weight_claim_reduction.input") + .expect("stage7 hamming input claim exists"); + assert_eq!( + input_claim.claim_value, + "stage7.hamming_weight_claim_reduction.input.claim_expr" + ); + let input_expr = verifier_program + .field_exprs + .iter() + .find(|expr| expr.symbol == "stage7.hamming_weight_claim_reduction.input.claim_expr") + .expect("stage7 hamming input claim is lowered to a field expression"); + assert_eq!( + input_expr.formula, + format!("field.power_strided_weighted_sum:{total_ra}:3:_:_:0,1,2") + ); + assert_eq!(input_expr.operands.len(), 1 + total_ra + 3 * total_ra); let output_expr = verifier_program .field_exprs .iter() @@ -2080,7 +2099,7 @@ fn stage7_rust_targets_extract_and_compile() { .expect("stage7 hamming output is lowered to a field expression"); assert_eq!( output_expr.formula, - format!("eval_family.weighted_sum:{total_ra}:3:0:1:2") + format!("field.power_strided_weighted_sum:{total_ra}:3:0:1:2") ); assert_eq!(output_expr.operands.len(), 2 * total_ra + 2); assert_eq!( @@ -2148,7 +2167,10 @@ fn stage7_rust_targets_extract_and_compile() { .contains("STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS")); assert!(verifier_source .source - .contains("Stage7FieldExprKind::EvalFamilyWeightedSum")); + .contains("Stage7FieldExprKind::PowerStridedWeightedSum")); + assert!(!verifier_source + .source + .contains("stage7.hamming_weight_claim_reduction.claim_expr.partial")); assert!(verifier_source .source .contains("stage7.hamming_weight_claim_reduction.output.eq.Booleanity")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 6f87f4131c..be599e2712 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -297,25 +297,25 @@ fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKin parts[2].parse::().expect("lagrange index is usize"), ) } - value if value.starts_with("eval_family.weighted_sum:") => { + value if value.starts_with("field.power_strided_weighted_sum:") => { let spec = value - .strip_prefix("eval_family.weighted_sum:") - .expect("weighted eval-family expression has prefix"); + .strip_prefix("field.power_strided_weighted_sum:") + .expect("power-strided weighted expression has prefix"); let parts = spec.split(':').collect::>(); assert!( parts.len() == 5, - "weighted eval-family expression has five fields" + "power-strided weighted expression has five fields" ); - bolt_verifier_runtime::FieldExprKind::EvalFamilyWeightedSum { - eval_count: parts[0] + bolt_verifier_runtime::FieldExprKind::PowerStridedWeightedSum { + row_count: parts[0] .parse::() - .expect("weighted eval-family eval count is usize"), + .expect("power-strided weighted row count is usize"), power_stride: parts[1] .parse::() - .expect("weighted eval-family power stride is usize"), + .expect("power-strided weighted power stride is usize"), value_term_offsets: leak_slice(parse_usize_list(parts[2])), shared_term_offsets: leak_slice(parse_usize_list(parts[3])), - item_term_offsets: leak_slice(parse_usize_list(parts[4])), + row_term_offsets: leak_slice(parse_usize_list(parts[4])), } } value => panic!("unsupported generated field expression kind `{value}`"), @@ -324,7 +324,7 @@ fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKin #[expect( clippy::expect_used, - reason = "equivalence adapters fail fast when a compiler weighted-sum field expression is malformed" + reason = "equivalence adapters fail fast when a compiler power-strided field expression is malformed" )] fn parse_usize_list(value: &str) -> Vec { if value == "_" { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 7ab55dcb33..ef5f908710 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -167,57 +167,14 @@ const fn stage7_field_expr(symbol: &'static str, kind: Stage7FieldExprKind, oper #[rustfmt::skip] pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[ - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", Stage7FieldExprKind::Pow(1), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", Stage7FieldExprKind::Pow(2), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", Stage7FieldExprKind::Pow(3), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", Stage7FieldExprKind::Pow(4), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_1"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", Stage7FieldExprKind::Pow(5), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", Stage7FieldExprKind::Pow(6), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", Stage7FieldExprKind::Pow(7), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", Stage7FieldExprKind::Pow(8), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", Stage7FieldExprKind::Pow(9), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", Stage7FieldExprKind::Pow(10), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", Stage7FieldExprKind::Pow(11), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", Stage7FieldExprKind::Pow(12), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", Stage7FieldExprKind::Pow(13), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_4"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", Stage7FieldExprKind::Pow(14), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", Stage7FieldExprKind::Pow(15), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", Stage7FieldExprKind::Pow(16), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_5"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", Stage7FieldExprKind::Pow(17), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", Stage7FieldExprKind::Pow(18), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", Stage7FieldExprKind::Pow(19), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_6"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", Stage7FieldExprKind::Pow(20), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", Stage7FieldExprKind::Pow(21), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", Stage7FieldExprKind::Pow(22), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_7"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", Stage7FieldExprKind::Pow(23), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", Stage7FieldExprKind::Pow(24), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", Stage7FieldExprKind::Pow(25), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_8"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", Stage7FieldExprKind::Pow(26), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", Stage7FieldExprKind::Pow(27), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", Stage7FieldExprKind::Pow(28), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_9"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", Stage7FieldExprKind::Pow(29), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", Stage7FieldExprKind::Pow(30), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", Stage7FieldExprKind::Pow(31), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_10"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", Stage7FieldExprKind::Pow(32), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", Stage7FieldExprKind::Pow(33), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", Stage7FieldExprKind::Pow(34), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_11"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", Stage7FieldExprKind::Pow(35), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", Stage7FieldExprKind::Pow(36), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", Stage7FieldExprKind::Pow(37), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_12"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", Stage7FieldExprKind::Pow(38), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", Stage7FieldExprKind::Pow(39), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", Stage7FieldExprKind::Pow(40), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_13"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", Stage7FieldExprKind::Pow(41), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", Stage7FieldExprKind::Pow(42), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", Stage7FieldExprKind::Pow(43), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_14"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", Stage7FieldExprKind::Pow(44), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", Stage7FieldExprKind::Pow(45), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", Stage7FieldExprKind::Pow(46), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_15"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", Stage7FieldExprKind::Pow(47), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", Stage7FieldExprKind::Pow(48), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", Stage7FieldExprKind::Pow(49), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_16"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", Stage7FieldExprKind::Pow(50), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", Stage7FieldExprKind::Pow(51), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", Stage7FieldExprKind::Pow(52), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_17"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", Stage7FieldExprKind::Pow(53), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", Stage7FieldExprKind::Pow(54), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", Stage7FieldExprKind::Pow(55), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_18"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", Stage7FieldExprKind::Pow(56), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", Stage7FieldExprKind::Pow(57), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", Stage7FieldExprKind::Pow(58), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_19"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", Stage7FieldExprKind::Pow(59), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", Stage7FieldExprKind::Pow(60), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", Stage7FieldExprKind::Pow(61), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_20"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", Stage7FieldExprKind::Pow(62), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", Stage7FieldExprKind::Pow(63), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", Stage7FieldExprKind::Pow(64), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_21"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", Stage7FieldExprKind::Pow(65), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", Stage7FieldExprKind::Pow(66), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", Stage7FieldExprKind::Pow(67), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_22"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", Stage7FieldExprKind::Pow(68), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", Stage7FieldExprKind::Pow(69), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", Stage7FieldExprKind::Pow(70), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_23"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", Stage7FieldExprKind::Pow(71), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", Stage7FieldExprKind::Pow(72), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", Stage7FieldExprKind::Pow(73), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_24"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", Stage7FieldExprKind::Pow(74), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", Stage7FieldExprKind::Pow(75), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", Stage7FieldExprKind::Pow(76), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_25"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", Stage7FieldExprKind::Pow(77), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", Stage7FieldExprKind::Pow(78), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", Stage7FieldExprKind::Pow(79), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_26"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", Stage7FieldExprKind::Pow(80), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", Stage7FieldExprKind::Pow(81), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", Stage7FieldExprKind::Pow(82), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_27"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", Stage7FieldExprKind::Pow(83), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", Stage7FieldExprKind::Pow(84), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", Stage7FieldExprKind::Pow(85), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_28"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", Stage7FieldExprKind::Pow(86), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", Stage7FieldExprKind::Pow(87), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", Stage7FieldExprKind::Pow(88), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_29"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", Stage7FieldExprKind::Pow(89), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", Stage7FieldExprKind::Pow(90), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", Stage7FieldExprKind::Pow(91), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_30"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", Stage7FieldExprKind::Pow(92), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", Stage7FieldExprKind::Pow(93), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", Stage7FieldExprKind::Pow(94), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_pow", "stage7.input.stage6.booleanity.InstructionRa_31"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", Stage7FieldExprKind::Pow(95), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_pow", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", Stage7FieldExprKind::Pow(96), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_pow", "stage7.field.one"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", Stage7FieldExprKind::Pow(97), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", Stage7FieldExprKind::Pow(98), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", Stage7FieldExprKind::Pow(99), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", Stage7FieldExprKind::Pow(100), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_1"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", Stage7FieldExprKind::Pow(101), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", Stage7FieldExprKind::Pow(102), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_pow", "stage7.field.one"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", Stage7FieldExprKind::Pow(103), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_pow", "stage7.input.stage6.booleanity.BytecodeRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", Stage7FieldExprKind::Pow(104), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_pow", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", Stage7FieldExprKind::Pow(105), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", Stage7FieldExprKind::Pow(106), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", Stage7FieldExprKind::Pow(107), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_0"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", Stage7FieldExprKind::Pow(108), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", Stage7FieldExprKind::Pow(109), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", Stage7FieldExprKind::Pow(110), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_1"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", Stage7FieldExprKind::Pow(111), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", Stage7FieldExprKind::Pow(112), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_2"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", Stage7FieldExprKind::Pow(113), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_2"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", Stage7FieldExprKind::Pow(114), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_pow", "stage7.input.stage6.hamming_booleanity.HammingWeight"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", Stage7FieldExprKind::Pow(115), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_pow", "stage7.input.stage6.booleanity.RamRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", Stage7FieldExprKind::Pow(116), &["stage7.hamming_weight_claim_reduction.gamma"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term", Stage7FieldExprKind::Mul, &["stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_pow", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial0", Stage7FieldExprKind::Add, &["stage7.field.one", "stage7.hamming_weight_claim_reduction.claim.0.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial1", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial0", "stage7.hamming_weight_claim_reduction.claim.0.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial2", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial1", "stage7.hamming_weight_claim_reduction.claim.1.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial3", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial2", "stage7.hamming_weight_claim_reduction.claim.1.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial4", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial3", "stage7.hamming_weight_claim_reduction.claim.1.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial5", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial4", "stage7.hamming_weight_claim_reduction.claim.2.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial6", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial5", "stage7.hamming_weight_claim_reduction.claim.2.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial7", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial6", "stage7.hamming_weight_claim_reduction.claim.2.virtualization.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial8", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial7", "stage7.hamming_weight_claim_reduction.claim.3.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial9", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial8", "stage7.hamming_weight_claim_reduction.claim.3.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial10", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial9", "stage7.hamming_weight_claim_reduction.claim.3.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial11", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial10", "stage7.hamming_weight_claim_reduction.claim.4.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial12", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial11", "stage7.hamming_weight_claim_reduction.claim.4.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial13", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial12", "stage7.hamming_weight_claim_reduction.claim.4.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial14", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial13", "stage7.hamming_weight_claim_reduction.claim.5.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial15", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial14", "stage7.hamming_weight_claim_reduction.claim.5.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial16", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial15", "stage7.hamming_weight_claim_reduction.claim.5.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial17", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial16", "stage7.hamming_weight_claim_reduction.claim.6.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial18", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial17", "stage7.hamming_weight_claim_reduction.claim.6.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial19", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial18", "stage7.hamming_weight_claim_reduction.claim.6.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial20", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial19", "stage7.hamming_weight_claim_reduction.claim.7.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial21", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial20", "stage7.hamming_weight_claim_reduction.claim.7.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial22", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial21", "stage7.hamming_weight_claim_reduction.claim.7.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial23", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial22", "stage7.hamming_weight_claim_reduction.claim.8.hw.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial24", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial23", "stage7.hamming_weight_claim_reduction.claim.8.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial25", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial24", "stage7.hamming_weight_claim_reduction.claim.8.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial26", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial25", "stage7.hamming_weight_claim_reduction.claim.9.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial27", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial26", "stage7.hamming_weight_claim_reduction.claim.9.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial28", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial27", "stage7.hamming_weight_claim_reduction.claim.9.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial29", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial28", "stage7.hamming_weight_claim_reduction.claim.10.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial30", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial29", "stage7.hamming_weight_claim_reduction.claim.10.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial31", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial30", "stage7.hamming_weight_claim_reduction.claim.10.virtualization.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial32", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial31", "stage7.hamming_weight_claim_reduction.claim.11.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial33", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial32", "stage7.hamming_weight_claim_reduction.claim.11.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial34", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial33", "stage7.hamming_weight_claim_reduction.claim.11.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial35", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial34", "stage7.hamming_weight_claim_reduction.claim.12.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial36", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial35", "stage7.hamming_weight_claim_reduction.claim.12.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial37", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial36", "stage7.hamming_weight_claim_reduction.claim.12.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial38", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial37", "stage7.hamming_weight_claim_reduction.claim.13.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial39", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial38", "stage7.hamming_weight_claim_reduction.claim.13.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial40", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial39", "stage7.hamming_weight_claim_reduction.claim.13.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial41", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial40", "stage7.hamming_weight_claim_reduction.claim.14.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial42", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial41", "stage7.hamming_weight_claim_reduction.claim.14.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial43", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial42", "stage7.hamming_weight_claim_reduction.claim.14.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial44", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial43", "stage7.hamming_weight_claim_reduction.claim.15.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial45", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial44", "stage7.hamming_weight_claim_reduction.claim.15.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial46", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial45", "stage7.hamming_weight_claim_reduction.claim.15.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial47", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial46", "stage7.hamming_weight_claim_reduction.claim.16.hw.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial48", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial47", "stage7.hamming_weight_claim_reduction.claim.16.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial49", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial48", "stage7.hamming_weight_claim_reduction.claim.16.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial50", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial49", "stage7.hamming_weight_claim_reduction.claim.17.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial51", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial50", "stage7.hamming_weight_claim_reduction.claim.17.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial52", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial51", "stage7.hamming_weight_claim_reduction.claim.17.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial53", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial52", "stage7.hamming_weight_claim_reduction.claim.18.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial54", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial53", "stage7.hamming_weight_claim_reduction.claim.18.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial55", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial54", "stage7.hamming_weight_claim_reduction.claim.18.virtualization.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial56", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial55", "stage7.hamming_weight_claim_reduction.claim.19.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial57", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial56", "stage7.hamming_weight_claim_reduction.claim.19.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial58", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial57", "stage7.hamming_weight_claim_reduction.claim.19.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial59", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial58", "stage7.hamming_weight_claim_reduction.claim.20.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial60", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial59", "stage7.hamming_weight_claim_reduction.claim.20.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial61", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial60", "stage7.hamming_weight_claim_reduction.claim.20.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial62", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial61", "stage7.hamming_weight_claim_reduction.claim.21.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial63", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial62", "stage7.hamming_weight_claim_reduction.claim.21.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial64", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial63", "stage7.hamming_weight_claim_reduction.claim.21.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial65", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial64", "stage7.hamming_weight_claim_reduction.claim.22.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial66", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial65", "stage7.hamming_weight_claim_reduction.claim.22.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial67", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial66", "stage7.hamming_weight_claim_reduction.claim.22.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial68", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial67", "stage7.hamming_weight_claim_reduction.claim.23.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial69", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial68", "stage7.hamming_weight_claim_reduction.claim.23.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial70", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial69", "stage7.hamming_weight_claim_reduction.claim.23.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial71", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial70", "stage7.hamming_weight_claim_reduction.claim.24.hw.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial72", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial71", "stage7.hamming_weight_claim_reduction.claim.24.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial73", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial72", "stage7.hamming_weight_claim_reduction.claim.24.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial74", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial73", "stage7.hamming_weight_claim_reduction.claim.25.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial75", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial74", "stage7.hamming_weight_claim_reduction.claim.25.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial76", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial75", "stage7.hamming_weight_claim_reduction.claim.25.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial77", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial76", "stage7.hamming_weight_claim_reduction.claim.26.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial78", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial77", "stage7.hamming_weight_claim_reduction.claim.26.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial79", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial78", "stage7.hamming_weight_claim_reduction.claim.26.virtualization.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial80", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial79", "stage7.hamming_weight_claim_reduction.claim.27.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial81", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial80", "stage7.hamming_weight_claim_reduction.claim.27.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial82", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial81", "stage7.hamming_weight_claim_reduction.claim.27.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial83", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial82", "stage7.hamming_weight_claim_reduction.claim.28.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial84", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial83", "stage7.hamming_weight_claim_reduction.claim.28.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial85", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial84", "stage7.hamming_weight_claim_reduction.claim.28.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial86", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial85", "stage7.hamming_weight_claim_reduction.claim.29.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial87", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial86", "stage7.hamming_weight_claim_reduction.claim.29.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial88", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial87", "stage7.hamming_weight_claim_reduction.claim.29.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial89", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial88", "stage7.hamming_weight_claim_reduction.claim.30.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial90", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial89", "stage7.hamming_weight_claim_reduction.claim.30.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial91", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial90", "stage7.hamming_weight_claim_reduction.claim.30.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial92", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial91", "stage7.hamming_weight_claim_reduction.claim.31.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial93", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial92", "stage7.hamming_weight_claim_reduction.claim.31.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial94", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial93", "stage7.hamming_weight_claim_reduction.claim.31.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial95", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial94", "stage7.hamming_weight_claim_reduction.claim.32.hw.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial96", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial95", "stage7.hamming_weight_claim_reduction.claim.32.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial97", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial96", "stage7.hamming_weight_claim_reduction.claim.32.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial98", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial97", "stage7.hamming_weight_claim_reduction.claim.33.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial99", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial98", "stage7.hamming_weight_claim_reduction.claim.33.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial100", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial99", "stage7.hamming_weight_claim_reduction.claim.33.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial101", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial100", "stage7.hamming_weight_claim_reduction.claim.34.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial102", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial101", "stage7.hamming_weight_claim_reduction.claim.34.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial103", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial102", "stage7.hamming_weight_claim_reduction.claim.34.virtualization.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial104", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial103", "stage7.hamming_weight_claim_reduction.claim.35.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial105", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial104", "stage7.hamming_weight_claim_reduction.claim.35.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial106", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial105", "stage7.hamming_weight_claim_reduction.claim.35.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial107", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial106", "stage7.hamming_weight_claim_reduction.claim.36.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial108", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial107", "stage7.hamming_weight_claim_reduction.claim.36.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial109", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial108", "stage7.hamming_weight_claim_reduction.claim.36.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial110", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial109", "stage7.hamming_weight_claim_reduction.claim.37.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial111", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial110", "stage7.hamming_weight_claim_reduction.claim.37.booleanity.gamma_term"]), - stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial112", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial111", "stage7.hamming_weight_claim_reduction.claim.37.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial113", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial112", "stage7.hamming_weight_claim_reduction.claim.38.hw.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial114", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial113", "stage7.hamming_weight_claim_reduction.claim.38.booleanity.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.claim_expr.partial115", Stage7FieldExprKind::Add, &["stage7.hamming_weight_claim_reduction.claim_expr.partial114", "stage7.hamming_weight_claim_reduction.claim.38.virtualization.gamma_term"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr", Stage7FieldExprKind::EvalFamilyWeightedSum { eval_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], item_term_offsets: &[2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), + stage7_field_expr("stage7.hamming_weight_claim_reduction.input.claim_expr", Stage7FieldExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[], shared_term_offsets: &[], row_term_offsets: &[0, 1, 2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.booleanity.InstructionRa_0", "stage7.input.stage6.booleanity.InstructionRa_1", "stage7.input.stage6.booleanity.InstructionRa_2", "stage7.input.stage6.booleanity.InstructionRa_3", "stage7.input.stage6.booleanity.InstructionRa_4", "stage7.input.stage6.booleanity.InstructionRa_5", "stage7.input.stage6.booleanity.InstructionRa_6", "stage7.input.stage6.booleanity.InstructionRa_7", "stage7.input.stage6.booleanity.InstructionRa_8", "stage7.input.stage6.booleanity.InstructionRa_9", "stage7.input.stage6.booleanity.InstructionRa_10", "stage7.input.stage6.booleanity.InstructionRa_11", "stage7.input.stage6.booleanity.InstructionRa_12", "stage7.input.stage6.booleanity.InstructionRa_13", "stage7.input.stage6.booleanity.InstructionRa_14", "stage7.input.stage6.booleanity.InstructionRa_15", "stage7.input.stage6.booleanity.InstructionRa_16", "stage7.input.stage6.booleanity.InstructionRa_17", "stage7.input.stage6.booleanity.InstructionRa_18", "stage7.input.stage6.booleanity.InstructionRa_19", "stage7.input.stage6.booleanity.InstructionRa_20", "stage7.input.stage6.booleanity.InstructionRa_21", "stage7.input.stage6.booleanity.InstructionRa_22", "stage7.input.stage6.booleanity.InstructionRa_23", "stage7.input.stage6.booleanity.InstructionRa_24", "stage7.input.stage6.booleanity.InstructionRa_25", "stage7.input.stage6.booleanity.InstructionRa_26", "stage7.input.stage6.booleanity.InstructionRa_27", "stage7.input.stage6.booleanity.InstructionRa_28", "stage7.input.stage6.booleanity.InstructionRa_29", "stage7.input.stage6.booleanity.InstructionRa_30", "stage7.input.stage6.booleanity.InstructionRa_31", "stage7.input.stage6.booleanity.BytecodeRa_0", "stage7.input.stage6.booleanity.BytecodeRa_1", "stage7.input.stage6.booleanity.BytecodeRa_2", "stage7.input.stage6.booleanity.RamRa_0", "stage7.input.stage6.booleanity.RamRa_1", "stage7.input.stage6.booleanity.RamRa_2", "stage7.input.stage6.booleanity.RamRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_0", "stage7.input.stage6.ram_ra_virtual.RamRa_1", "stage7.input.stage6.ram_ra_virtual.RamRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr", Stage7FieldExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), ]; pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ ]; pub const STAGE7_SUMCHECK_CLAIMS: &[Stage7SumcheckClaimPlan] = &[ - Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some(Stage7RelationKind::Stage7HammingWeightClaimReduction), claim_value: "stage7.hamming_weight_claim_reduction.claim_expr.partial115" }, + Stage7SumcheckClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.input", stage: "stage7", domain: "jolt.stage7_hamming_weight_claim_reduction_domain", num_rounds: 4, degree: 2, claim: "stage7.hamming_weight_claim_reduction.weighted_stage6_claims", kernel: None, relation: Some(Stage7RelationKind::Stage7HammingWeightClaimReduction), claim_value: "stage7.hamming_weight_claim_reduction.input.claim_expr" }, ]; pub const STAGE7_SUMCHECK_BATCH_0_ROUND_SCHEDULE: &[usize] = &[4]; From 5325df64a0aa61a94769be78644fa261bb7e32b5 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 22:36:27 -0600 Subject: [PATCH 107/171] refactor(bolt): split verifier value expressions Move field-vector reductions and power-strided weighted rows out of FieldExprKind and into verifier value-expression plans. Thread value_exprs through runtime claim evaluation, relation output evaluation, generated verifier artifacts, and equivalence adapters. --- crates/bolt-verifier-runtime/src/lib.rs | 172 +++++++++++++----- .../src/protocols/jolt/emit/rust/stage2.rs | 7 +- .../src/protocols/jolt/emit/rust/stage3.rs | 34 +++- .../src/protocols/jolt/emit/rust/stage4.rs | 39 +++- .../src/protocols/jolt/emit/rust/stage5.rs | 86 ++++++++- .../src/protocols/jolt/emit/rust/stage6.rs | 93 ++++++++-- .../src/protocols/jolt/emit/rust/stage7.rs | 103 +++++++++-- .../src/protocols/jolt/rust_target_plan.rs | 77 +++++--- .../bolt/src/protocols/jolt/verifier_plan.rs | 112 +++++++++++- .../src/protocols/jolt/verifier_values.rs | 1 + crates/bolt/tests/commitment_ir.rs | 11 +- crates/jolt-equivalence/src/plan_adapters.rs | 54 +++++- .../src/plan_adapters/generated_stage2.rs | 3 +- .../src/plan_adapters/generated_stage3.rs | 1 + .../src/plan_adapters/generated_stage4.rs | 1 + .../src/plan_adapters/generated_stage5.rs | 1 + .../src/plan_adapters/generated_stage6.rs | 1 + .../src/plan_adapters/generated_stage7.rs | 1 + crates/jolt-verifier/src/stages/stage2.rs | 5 +- crates/jolt-verifier/src/stages/stage3.rs | 12 +- crates/jolt-verifier/src/stages/stage4.rs | 12 +- crates/jolt-verifier/src/stages/stage5.rs | 14 +- crates/jolt-verifier/src/stages/stage6.rs | 19 +- crates/jolt-verifier/src/stages/stage7.rs | 19 +- 24 files changed, 746 insertions(+), 132 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 2a55ec139a..26c4f703e2 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -246,11 +246,22 @@ pub enum FieldExprKind { Mul, Sum, Product, - FieldVectorSum, - FieldVectorProduct, Neg, Pow(usize), LagrangeBasisEval(i64, usize, usize), +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct FieldExprPlan { + pub symbol: &'static str, + pub kind: FieldExprKind, + pub operands: &'static [&'static str], +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ValueExprKind { + FieldVectorSum, + FieldVectorProduct, PowerStridedWeightedSum { row_count: usize, power_stride: usize, @@ -261,9 +272,9 @@ pub enum FieldExprKind { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct FieldExprPlan { +pub struct ValueExprPlan { pub symbol: &'static str, - pub kind: FieldExprKind, + pub kind: ValueExprKind, pub operands: &'static [&'static str], } @@ -481,6 +492,7 @@ pub struct StageProgramPlan { pub opening_inputs: &'static [OpeningInputPlan], pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], + pub value_exprs: &'static [ValueExprPlan], pub kernels: &'static [KernelPlan], pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], @@ -507,6 +519,7 @@ pub struct StageProgramPlanNoPointZeros { pub opening_inputs: &'static [OpeningInputPlan], pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], + pub value_exprs: &'static [ValueExprPlan], pub kernels: &'static [KernelPlan], pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], @@ -530,6 +543,7 @@ pub struct StageVerifierProgramPlan { pub opening_inputs: &'static [OpeningInputPlan], pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], + pub value_exprs: &'static [ValueExprPlan], pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], pub drivers: &'static [SumcheckDriverPlan], @@ -552,6 +566,7 @@ pub struct StageVerifierProgramPlanNoEqualities { pub opening_inputs: &'static [OpeningInputPlan], pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], + pub value_exprs: &'static [ValueExprPlan], pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], pub drivers: &'static [SumcheckDriverPlan], @@ -951,7 +966,7 @@ impl ValueStore { if self.try_scalar(expr.symbol).is_some() { continue; } - let Some(operands) = self.try_expr_operands(expr) else { + let Some(operands) = self.try_field_expr_operands(expr) else { continue; }; self.insert_scalar(expr.symbol, evaluate(expr, &operands)?); @@ -963,6 +978,39 @@ impl ValueStore { } } + pub fn evaluate_available_exprs( + &mut self, + field_exprs: &[FieldExprPlan], + value_exprs: &[ValueExprPlan], + ) -> Result<(), RuntimePlanError> { + loop { + let mut progress = 0usize; + for expr in field_exprs { + if self.try_scalar(expr.symbol).is_some() { + continue; + } + let Some(operands) = self.try_field_expr_operands(expr) else { + continue; + }; + self.insert_scalar(expr.symbol, evaluate_field_expr(expr, &operands)?); + progress += 1; + } + for expr in value_exprs { + if self.try_scalar(expr.symbol).is_some() { + continue; + } + let Some(operands) = self.try_value_expr_operands(expr) else { + continue; + }; + self.insert_scalar(expr.symbol, evaluate_value_expr(expr, &operands)?); + progress += 1; + } + if progress == 0 { + return Ok(()); + } + } + } + pub fn evaluate_named_eval_families( &mut self, families: &[NamedEvalFamilyPlan], @@ -1083,15 +1131,22 @@ impl ValueStore { .map(|(_, values)| values.as_slice()) } - fn try_expr_operands(&self, expr: &FieldExprPlan) -> Option> { + fn try_field_expr_operands(&self, expr: &FieldExprPlan) -> Option> { + expr.operands + .iter() + .map(|operand| self.try_scalar(operand)) + .collect() + } + + fn try_value_expr_operands(&self, expr: &ValueExprPlan) -> Option> { match expr.kind { - FieldExprKind::FieldVectorSum | FieldExprKind::FieldVectorProduct => { + ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { let [symbol] = expr.operands else { return Some(Vec::new()); }; self.try_field_vector(symbol).map(|values| values.to_vec()) } - _ => expr + ValueExprKind::PowerStridedWeightedSum { .. } => expr .operands .iter() .map(|operand| self.try_scalar(operand)) @@ -1140,12 +1195,13 @@ pub fn batch_claims<'a, C: SymbolPlan>( pub fn batch_claim_values( claims: &[&C], field_exprs: &[FieldExprPlan], + value_exprs: &[ValueExprPlan], store: &mut ValueStore, ) -> Result, RuntimePlanError> { claims .iter() .map(|claim| { - store.evaluate_available_field_exprs(field_exprs, evaluate_field_expr)?; + store.evaluate_available_exprs(field_exprs, value_exprs)?; store.scalar_or(claim.claim_value(), |symbol| { RuntimePlanError::MissingValue { symbol } }) @@ -1159,6 +1215,7 @@ pub fn verify_batched_sumcheck( claims: &'static [C], batches: &'static [SumcheckBatchPlan], field_exprs: &'static [FieldExprPlan], + value_exprs: &'static [ValueExprPlan], opening_inputs: &'static [OpeningInputPlan], opening_claims: &'static [OpeningClaimPlan], opening_batches: &'static [OpeningBatchPlan], @@ -1186,7 +1243,7 @@ where } let batch = find_batch(batches, driver.symbol(), driver.batch())?; let claims = batch_claims(claims, batch)?; - let input_claims = batch_claim_values(&claims, field_exprs, store)?; + let input_claims = batch_claim_values(&claims, field_exprs, value_exprs, store)?; for claim in &input_claims { append_labeled_scalar(transcript, batch.claim_label, claim); } @@ -1269,6 +1326,7 @@ pub fn evaluate_relation_output( plan: &RelationOutputPlan, relation_output_values: &[StructuredPolynomialEvalPlan], field_exprs: &[FieldExprPlan], + value_exprs: &[ValueExprPlan], store: &ValueStore, instance_symbol: &'static str, evals: &[StageNamedEval], @@ -1327,7 +1385,7 @@ pub fn evaluate_relation_output( let value = evaluate_structured_polynomial(polynomial_eval.polynomial, &x_point, y_point)?; scratch.insert(polynomial_eval.symbol, value); } - evaluate_available_field_exprs_with_scratch(field_exprs, store, &mut scratch)?; + evaluate_available_exprs_with_scratch(field_exprs, value_exprs, store, &mut scratch)?; scratch .scalar_or(store, plan.expected_output) .ok_or(RuntimePlanError::MissingValue { @@ -1339,6 +1397,7 @@ pub fn evaluate_relation_output_for_instance( relation_outputs: &[RelationOutputPlan], relation_output_values: &[StructuredPolynomialEvalPlan], field_exprs: &[FieldExprPlan], + value_exprs: &[ValueExprPlan], store: &ValueStore, instance: &SumcheckInstanceResultPlan, evals: &[StageNamedEval], @@ -1357,6 +1416,7 @@ pub fn evaluate_relation_output_for_instance( relation_output, relation_output_values, field_exprs, + value_exprs, store, instance.symbol, evals, @@ -1464,8 +1524,9 @@ impl ScratchScalars { } } -fn evaluate_available_field_exprs_with_scratch( +fn evaluate_available_exprs_with_scratch( field_exprs: &[FieldExprPlan], + value_exprs: &[ValueExprPlan], store: &ValueStore, scratch: &mut ScratchScalars, ) -> Result<(), RuntimePlanError> { @@ -1481,6 +1542,16 @@ fn evaluate_available_field_exprs_with_scratch( scratch.insert(expr.symbol, evaluate_field_expr(expr, &operands)?); progress += 1; } + for expr in value_exprs { + if scratch.scalar_or(store, expr.symbol).is_some() { + continue; + } + let Some(operands) = relation_output_value_expr_operands(expr, store, scratch) else { + continue; + }; + scratch.insert(expr.symbol, evaluate_value_expr(expr, &operands)?); + progress += 1; + } if progress == 0 { return Ok(()); } @@ -1491,15 +1562,26 @@ fn relation_output_expr_operands( expr: &FieldExprPlan, store: &ValueStore, scratch: &ScratchScalars, +) -> Option> { + expr.operands + .iter() + .map(|operand| scratch.scalar_or(store, operand)) + .collect() +} + +fn relation_output_value_expr_operands( + expr: &ValueExprPlan, + store: &ValueStore, + scratch: &ScratchScalars, ) -> Option> { match expr.kind { - FieldExprKind::FieldVectorSum | FieldExprKind::FieldVectorProduct => { + ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { let [symbol] = expr.operands else { return Some(Vec::new()); }; store.try_field_vector(symbol).map(|values| values.to_vec()) } - _ => expr + ValueExprKind::PowerStridedWeightedSum { .. } => expr .operands .iter() .map(|operand| scratch.scalar_or(store, operand)) @@ -1579,20 +1661,6 @@ pub fn evaluate_field_expr( .copied() .fold(F::from_u64(1), |acc, operand| acc * operand)) } - FieldExprKind::FieldVectorSum => { - require_min_operand_count(expr.symbol, 1, operands.len())?; - Ok(operands - .iter() - .copied() - .fold(F::from_u64(0), |acc, operand| acc + operand)) - } - FieldExprKind::FieldVectorProduct => { - require_min_operand_count(expr.symbol, 1, operands.len())?; - Ok(operands - .iter() - .copied() - .fold(F::from_u64(1), |acc, operand| acc * operand)) - } FieldExprKind::Neg => { require_operand_count(expr.symbol, 1, operands.len())?; Ok(-operands[0]) @@ -1613,7 +1681,29 @@ pub fn evaluate_field_expr( actual: weights.len(), }) } - FieldExprKind::PowerStridedWeightedSum { + } +} + +pub fn evaluate_value_expr( + expr: &ValueExprPlan, + operands: &[F], +) -> Result { + match expr.kind { + ValueExprKind::FieldVectorSum => { + require_min_operand_count(expr.symbol, 1, operands.len())?; + Ok(operands + .iter() + .copied() + .fold(F::from_u64(0), |acc, operand| acc + operand)) + } + ValueExprKind::FieldVectorProduct => { + require_min_operand_count(expr.symbol, 1, operands.len())?; + Ok(operands + .iter() + .copied() + .fold(F::from_u64(1), |acc, operand| acc * operand)) + } + ValueExprKind::PowerStridedWeightedSum { row_count, power_stride, value_term_offsets, @@ -1824,8 +1914,8 @@ pub fn reverse_slice(values: &[Fr]) -> Vec { )] mod tests { use super::{ - evaluate_field_expr, FieldExprKind, FieldExprPlan, Fr, NamedEvalFamilyPlan, - RuntimePlanError, ValueStore, + evaluate_value_expr, Fr, NamedEvalFamilyPlan, RuntimePlanError, ValueExprKind, + ValueExprPlan, ValueStore, }; #[test] @@ -1871,20 +1961,20 @@ mod tests { store.insert_field_vector("family.ab", vec![Fr::from_u64(2), Fr::from_u64(3)]); store - .evaluate_available_field_exprs( + .evaluate_available_exprs( + &[], &[ - FieldExprPlan { + ValueExprPlan { symbol: "family.ab.product", - kind: FieldExprKind::FieldVectorProduct, + kind: ValueExprKind::FieldVectorProduct, operands: &["family.ab"], }, - FieldExprPlan { + ValueExprPlan { symbol: "family.ab.sum", - kind: FieldExprKind::FieldVectorSum, + kind: ValueExprKind::FieldVectorSum, operands: &["family.ab"], }, ], - evaluate_field_expr, ) .unwrap(); @@ -1893,11 +1983,11 @@ mod tests { } #[test] - fn field_expr_evaluates_power_strided_weighted_sum() { - let value = evaluate_field_expr( - &FieldExprPlan { + fn value_expr_evaluates_power_strided_weighted_sum() { + let value = evaluate_value_expr( + &ValueExprPlan { symbol: "family.weighted", - kind: FieldExprKind::PowerStridedWeightedSum { + kind: ValueExprKind::PowerStridedWeightedSum { row_count: 2, power_stride: 3, value_term_offsets: &[0], diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 2d74aae65a..14bc4eba7f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -1000,6 +1000,7 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage2ClaimKind, FieldConstantPlan as Stage2FieldConstantPlan, FieldExprKind as Stage2FieldExprKind, FieldExprPlan as Stage2FieldExprPlan, + ValueExprPlan as Stage2ValueExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, OpeningInputPlan as Stage2OpeningInputPlan, PointConcatPlan as Stage2PointConcatPlan, PointSlicePlan as Stage2PointSlicePlan, ProgramStepKind as Stage2ProgramStepKind, @@ -1108,6 +1109,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); \x20 opening_inputs: STAGE2_OPENING_INPUTS,\n\ \x20 field_constants: STAGE2_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE2_FIELD_EXPRS,\n\ + \x20 value_exprs: STAGE2_VALUE_EXPRS,\n\ \x20 claims: STAGE2_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE2_SUMCHECK_BATCHES,\n\ \x20 drivers: STAGE2_SUMCHECK_DRIVERS,\n\ @@ -1148,6 +1150,9 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); + if self.role == Role::Verifier { + source.push_str("pub const STAGE2_VALUE_EXPRS: &[Stage2ValueExprPlan] = &[];\n"); + } Ok(source) } @@ -2160,7 +2165,7 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, ) -> Result<(), VerifyStage2Error> { self.0 - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage2Error::from) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 90bf871d71..29e325cf54 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -26,6 +26,7 @@ pub struct Stage3CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, + pub value_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -98,6 +99,15 @@ pub struct Stage3FieldExprPlan { pub operands: Vec, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage3ValueExprPlan { + pub symbol: String, + pub kind: String, + pub formula: String, + pub operand_names: Vec, + pub operands: Vec, +} + impl FieldExprDependencies for Stage3FieldExprPlan { fn symbol(&self) -> &str { &self.symbol @@ -229,6 +239,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_input = Stage3OpeningInputPlan, field_constant = Stage3FieldConstantPlan, field_expr = Stage3FieldExprPlan, + value_expr = Stage3ValueExprPlan, claim = Stage3SumcheckClaimPlan, batch = Stage3SumcheckBatchPlan, driver = Stage3SumcheckDriverPlan, @@ -265,6 +276,7 @@ impl Stage3CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); + let value_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -603,6 +615,7 @@ impl Stage3CpuProgram { opening_inputs, field_constants, field_exprs, + value_exprs, kernels, claims, batches, @@ -1152,6 +1165,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage3ClaimKind, FieldConstantPlan as Stage3FieldConstantPlan, FieldExprKind as Stage3FieldExprKind, FieldExprPlan as Stage3FieldExprPlan, + ValueExprKind as Stage3ValueExprKind, + ValueExprPlan as Stage3ValueExprPlan, OpeningBatchPlan as Stage3OpeningBatchPlan, OpeningClaimEqualityPlan as Stage3OpeningClaimEqualityPlan, OpeningClaimPlan as Stage3OpeningClaimPlan, OpeningInputPlan as Stage3OpeningInputPlan, @@ -1232,6 +1247,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); \x20 opening_inputs: STAGE3_OPENING_INPUTS,\n\ \x20 field_constants: STAGE3_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE3_FIELD_EXPRS,\n\ + \x20 value_exprs: STAGE3_VALUE_EXPRS,\n\ \x20 claims: STAGE3_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE3_SUMCHECK_BATCHES,\n\ \x20 drivers: STAGE3_SUMCHECK_DRIVERS,\n\ @@ -1265,6 +1281,9 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); + if self.role == Role::Verifier { + source.push_str(&self.emit_value_expr_constants()?); + } Ok(source) } @@ -1430,6 +1449,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); Ok(source) } + fn emit_value_expr_constants(&self) -> Result { + let plan = self.verifier_plan()?; + Ok(verifier_plan::emit_value_expr_constants( + "Stage3", + "STAGE3", + &plan.value_exprs, + )) + } + fn emit_kernel_constants(&self) -> String { let kernels = self .kernels @@ -2017,7 +2045,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage3Error::from)?; artifacts.challenge_vectors.push(Stage3ChallengeVector { symbol: squeeze.symbol, @@ -2084,6 +2112,7 @@ where program.claims, program.batches, program.field_exprs, + program.value_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -2136,7 +2165,7 @@ fn observe_stage3_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage3Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2176,6 +2205,7 @@ fn expected_batched_output_claim( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index ea8b4b977a..3ad45ddf93 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -32,6 +32,7 @@ pub struct Stage4CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, + pub value_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -111,6 +112,15 @@ pub struct Stage4FieldExprPlan { pub operands: Vec, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage4ValueExprPlan { + pub symbol: String, + pub kind: String, + pub formula: String, + pub operand_names: Vec, + pub operands: Vec, +} + impl FieldExprDependencies for Stage4FieldExprPlan { fn symbol(&self) -> &str { &self.symbol @@ -242,6 +252,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_input = Stage4OpeningInputPlan, field_constant = Stage4FieldConstantPlan, field_expr = Stage4FieldExprPlan, + value_expr = Stage4ValueExprPlan, claim = Stage4SumcheckClaimPlan, batch = Stage4SumcheckBatchPlan, driver = Stage4SumcheckDriverPlan, @@ -280,6 +291,7 @@ impl Stage4CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); + let value_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -616,6 +628,7 @@ impl Stage4CpuProgram { opening_inputs, field_constants, field_exprs, + value_exprs, kernels, claims, batches, @@ -1364,6 +1377,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage4ClaimKind, FieldConstantPlan as Stage4FieldConstantPlan, FieldExprKind as Stage4FieldExprKind, FieldExprPlan as Stage4FieldExprPlan, + ValueExprKind as Stage4ValueExprKind, + ValueExprPlan as Stage4ValueExprPlan, KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan, OpeningClaimEqualityPlan as Stage4OpeningClaimEqualityPlan, OpeningClaimPlan as Stage4OpeningClaimPlan, OpeningInputPlan as Stage4OpeningInputPlan, @@ -1426,6 +1441,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } else { "" }; + let value_exprs_field = if self.role == Role::Verifier { + " value_exprs: STAGE4_VALUE_EXPRS,\n" + } else { + "" + }; push_format( &mut source, format_args!( @@ -1438,6 +1458,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); \x20 opening_inputs: STAGE4_OPENING_INPUTS,\n\ \x20 field_constants: STAGE4_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE4_FIELD_EXPRS,\n\ + {value_exprs_field}\ \x20 kernels: STAGE4_KERNELS,\n\ \x20 claims: STAGE4_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE4_SUMCHECK_BATCHES,\n\ @@ -1475,6 +1496,9 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); + if self.role == Role::Verifier { + source.push_str(&self.emit_value_expr_constants()?); + } Ok(source) } @@ -1663,6 +1687,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); Ok(source) } + fn emit_value_expr_constants(&self) -> Result { + let plan = self.verifier_plan()?; + Ok(verifier_plan::emit_value_expr_constants( + "Stage4", + "STAGE4", + &plan.value_exprs, + )) + } + fn emit_kernel_constants(&self) -> String { let kernels = self .kernels @@ -2244,7 +2277,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage4Error::from)?; artifacts.challenge_vectors.push(Stage4ChallengeVector { symbol: squeeze.symbol, @@ -2322,6 +2355,7 @@ where program.claims, program.batches, program.field_exprs, + program.value_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -2377,7 +2411,7 @@ fn observe_stage4_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage4Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2417,6 +2451,7 @@ fn expected_batched_output_claim( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index be12492e31..37f7a25ed4 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -11,7 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::FieldExprKind; +use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ValueExprKind}; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, }; @@ -43,6 +43,7 @@ pub struct Stage5CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, + pub value_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -125,6 +126,15 @@ pub struct Stage5FieldExprPlan { pub operands: Vec, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage5ValueExprPlan { + pub symbol: String, + pub kind: String, + pub formula: String, + pub operand_names: Vec, + pub operands: Vec, +} + impl FieldExprDependencies for Stage5FieldExprPlan { fn symbol(&self) -> &str { &self.symbol @@ -212,6 +222,16 @@ fn stage5_field_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage } } +fn stage5_value_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage5ValueExprPlan { + Stage5ValueExprPlan { + symbol: expr.symbol, + kind: "op".to_owned(), + formula: expr.formula, + operand_names: expr.operands.clone(), + operands: expr.operands, + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5PointSlicePlan { pub symbol: String, @@ -266,6 +286,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_input = Stage5OpeningInputPlan, field_constant = Stage5FieldConstantPlan, field_expr = Stage5FieldExprPlan, + value_expr = Stage5ValueExprPlan, claim = Stage5SumcheckClaimPlan, batch = Stage5SumcheckBatchPlan, driver = Stage5SumcheckDriverPlan, @@ -308,6 +329,7 @@ impl Stage5CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); + let mut value_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -662,7 +684,13 @@ impl Stage5CpuProgram { value_ref.index += relation_output_value_base; } relation_output_values.extend(output_plan.relation_output_values); - field_exprs.extend(output_plan.field_exprs.into_iter().map(stage5_field_expr)); + for expr in output_plan.field_exprs { + if ValueExprKind::from_cpu_attr(&expr.formula).is_ok() { + value_exprs.push(stage5_value_expr(expr)); + } else { + field_exprs.push(stage5_field_expr(expr)); + } + } relation_outputs.push(output_claim); } @@ -677,6 +705,7 @@ impl Stage5CpuProgram { opening_inputs, field_constants, field_exprs, + value_exprs, kernels, claims, batches, @@ -780,10 +809,28 @@ impl Stage5CpuProgram { expr.operand_names.len(), expr.operands.len(), )?; - let kind = FieldExprKind::from_cpu_attr(&expr.formula) + let _kind = FieldExprKind::from_cpu_attr(&expr.formula) + .map_err(|error| EmitError::new(error.to_string()))?; + for operand in &expr.operands { + if !field_values.contains(operand) { + return Err(EmitError::new(format!( + "field expr @{} references missing field value @{operand}", + expr.symbol + ))); + } + } + } + for expr in &self.value_exprs { + verify_count( + "value expr operands", + &expr.symbol, + expr.operand_names.len(), + expr.operands.len(), + )?; + let kind = ValueExprKind::from_cpu_attr(&expr.formula) .map_err(|error| EmitError::new(error.to_string()))?; match kind { - FieldExprKind::FieldVectorSum | FieldExprKind::FieldVectorProduct => { + ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { verify_count( "field vector expr operands", &expr.symbol, @@ -801,11 +848,11 @@ impl Stage5CpuProgram { ))); } } - _ => { + ValueExprKind::PowerStridedWeightedSum { .. } => { for operand in &expr.operands { if !field_values.contains(operand) { return Err(EmitError::new(format!( - "field expr @{} references missing field value @{operand}", + "value expr @{} references missing field value @{operand}", expr.symbol ))); } @@ -1504,6 +1551,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage5ClaimKind, FieldConstantPlan as Stage5FieldConstantPlan, FieldExprKind as Stage5FieldExprKind, FieldExprPlan as Stage5FieldExprPlan, + ValueExprKind as Stage5ValueExprKind, + ValueExprPlan as Stage5ValueExprPlan, KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan, OpeningClaimEqualityPlan as Stage5OpeningClaimEqualityPlan, OpeningClaimPlan as Stage5OpeningClaimPlan, OpeningInputPlan as Stage5OpeningInputPlan, @@ -1567,6 +1616,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } else { "" }; + let value_exprs_field = if self.role == Role::Verifier { + " value_exprs: STAGE5_VALUE_EXPRS,\n" + } else { + "" + }; push_format( &mut source, format_args!( @@ -1579,6 +1633,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); \x20 opening_inputs: STAGE5_OPENING_INPUTS,\n\ \x20 field_constants: STAGE5_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE5_FIELD_EXPRS,\n\ + {value_exprs_field}\ \x20 kernels: STAGE5_KERNELS,\n\ \x20 claims: STAGE5_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE5_SUMCHECK_BATCHES,\n\ @@ -1616,6 +1671,9 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); + if self.role == Role::Verifier { + source.push_str(&self.emit_value_expr_constants()?); + } Ok(source) } @@ -1804,6 +1862,15 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); Ok(source) } + fn emit_value_expr_constants(&self) -> Result { + let plan = self.verifier_plan()?; + Ok(verifier_plan::emit_value_expr_constants( + "Stage5", + "STAGE5", + &plan.value_exprs, + )) + } + fn emit_kernel_constants(&self) -> String { let kernels = self .kernels @@ -2363,7 +2430,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage5Error::from)?; artifacts.challenge_vectors.push(Stage5ChallengeVector { symbol: squeeze.symbol, @@ -2441,6 +2508,7 @@ where program.claims, program.batches, program.field_exprs, + program.value_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -2497,7 +2565,7 @@ fn observe_stage5_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage5Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2549,6 +2617,7 @@ fn expected_batched_output_claim( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, @@ -2563,6 +2632,7 @@ fn expected_batched_output_claim( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index e42fb03791..339cb158c6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -11,7 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::FieldExprKind; +use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ValueExprKind}; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, stage6_bytecode_read_raf_relation_output_plan, STAGE6_BYTECODE_RA_EVAL_FAMILY, @@ -72,6 +72,7 @@ pub struct Stage6CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, + pub value_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -155,6 +156,15 @@ pub struct Stage6FieldExprPlan { pub operands: Vec, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage6ValueExprPlan { + pub symbol: String, + pub kind: String, + pub formula: String, + pub operand_names: Vec, + pub operands: Vec, +} + impl FieldExprDependencies for Stage6FieldExprPlan { fn symbol(&self) -> &str { &self.symbol @@ -293,6 +303,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_input = Stage6OpeningInputPlan, field_constant = Stage6FieldConstantPlan, field_expr = Stage6FieldExprPlan, + value_expr = Stage6ValueExprPlan, claim = Stage6SumcheckClaimPlan, batch = Stage6SumcheckBatchPlan, driver = Stage6SumcheckDriverPlan, @@ -336,6 +347,7 @@ impl Stage6CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); + let mut value_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -704,12 +716,13 @@ impl Stage6CpuProgram { )?; let bytecode_output_plan = stage6_bytecode_read_raf_relation_output_plan(bytecode_ra_evals); - field_exprs.extend( - bytecode_output_plan - .field_exprs - .into_iter() - .map(stage6_relation_output_expr), - ); + for expr in bytecode_output_plan.field_exprs { + if ValueExprKind::from_cpu_attr(&expr.formula).is_ok() { + value_exprs.push(stage6_value_expr(expr)); + } else { + field_exprs.push(stage6_relation_output_expr(expr)); + } + } relation_outputs.push(bytecode_output_plan.claim); } @@ -724,6 +737,7 @@ impl Stage6CpuProgram { opening_inputs, field_constants, field_exprs, + value_exprs, kernels, claims, batches, @@ -828,10 +842,28 @@ impl Stage6CpuProgram { expr.operand_names.len(), expr.operands.len(), )?; - let kind = FieldExprKind::from_cpu_attr(&expr.formula) + let _kind = FieldExprKind::from_cpu_attr(&expr.formula) + .map_err(|error| EmitError::new(error.to_string()))?; + for operand in &expr.operands { + if !field_values.contains(operand) { + return Err(EmitError::new(format!( + "field expr @{} references missing field value @{operand}", + expr.symbol + ))); + } + } + } + for expr in &self.value_exprs { + verify_count( + "value expr operands", + &expr.symbol, + expr.operand_names.len(), + expr.operands.len(), + )?; + let kind = ValueExprKind::from_cpu_attr(&expr.formula) .map_err(|error| EmitError::new(error.to_string()))?; match kind { - FieldExprKind::FieldVectorSum | FieldExprKind::FieldVectorProduct => { + ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { verify_count( "field vector expr operands", &expr.symbol, @@ -849,11 +881,11 @@ impl Stage6CpuProgram { ))); } } - _ => { + ValueExprKind::PowerStridedWeightedSum { .. } => { for operand in &expr.operands { if !field_values.contains(operand) { return Err(EmitError::new(format!( - "field expr @{} references missing field value @{operand}", + "value expr @{} references missing field value @{operand}", expr.symbol ))); } @@ -1558,6 +1590,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage6ClaimKind, FieldConstantPlan as Stage6FieldConstantPlan, FieldExprKind as Stage6FieldExprKind, FieldExprPlan as Stage6FieldExprPlan, + ValueExprKind as Stage6ValueExprKind, + ValueExprPlan as Stage6ValueExprPlan, KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan, OpeningClaimEqualityPlan as Stage6OpeningClaimEqualityPlan, OpeningClaimPlan as Stage6OpeningClaimPlan, OpeningInputPlan as Stage6OpeningInputPlan, @@ -1684,6 +1718,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); } else { "" }; + let value_exprs_field = if self.role == Role::Verifier { + " value_exprs: STAGE6_VALUE_EXPRS,\n" + } else { + "" + }; push_format( &mut source, format_args!( @@ -1696,6 +1735,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); \x20 opening_inputs: STAGE6_OPENING_INPUTS,\n\ \x20 field_constants: STAGE6_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE6_FIELD_EXPRS,\n\ + {value_exprs_field}\ \x20 kernels: STAGE6_KERNELS,\n\ \x20 claims: STAGE6_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE6_SUMCHECK_BATCHES,\n\ @@ -1734,6 +1774,9 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); + if self.role == Role::Verifier { + source.push_str(&self.emit_value_expr_constants()?); + } Ok(source) } @@ -1924,6 +1967,17 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); Ok(source) } + fn emit_value_expr_constants(&self) -> Result { + let plan = self.verifier_plan()?; + Ok(verifier_plan::emit_value_expr_constants_chunked( + "Stage6", + "STAGE6", + "stage6_value_expr", + &plan.value_exprs, + 16, + )) + } + fn emit_kernel_constants(&self) -> String { let kernels = self .kernels @@ -2525,7 +2579,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage6Error::from)?; artifacts.challenge_vectors.push(Stage6ChallengeVector { symbol: squeeze.symbol, @@ -2605,6 +2659,7 @@ where program.claims, program.batches, program.field_exprs, + program.value_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -2668,7 +2723,7 @@ fn observe_stage6_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage6Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2761,6 +2816,7 @@ fn expected_plan_relation_output( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, @@ -2865,6 +2921,17 @@ fn stage6_relation_output_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage } } +fn stage6_value_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage6ValueExprPlan { + let operands = expr.operands; + Stage6ValueExprPlan { + symbol: expr.symbol, + kind: "op".to_owned(), + formula: expr.formula, + operand_names: operands.clone(), + operands, + } +} + fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { STAGE6_KERNEL_ABIS .iter() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 690ed022f7..a13b0012ae 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -11,7 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::power_strided_weighted_sum_formula; +use crate::protocols::jolt::rust_target_plan::{power_strided_weighted_sum_formula, ValueExprKind}; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, @@ -52,6 +52,7 @@ pub struct Stage7CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, + pub value_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -135,6 +136,15 @@ pub struct Stage7FieldExprPlan { pub operands: Vec, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage7ValueExprPlan { + pub symbol: String, + pub kind: String, + pub formula: String, + pub operand_names: Vec, + pub operands: Vec, +} + impl FieldExprDependencies for Stage7FieldExprPlan { fn symbol(&self) -> &str { &self.symbol @@ -155,6 +165,16 @@ fn stage7_relation_output_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage } } +fn stage7_value_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage7ValueExprPlan { + Stage7ValueExprPlan { + symbol: expr.symbol, + kind: "op".to_owned(), + formula: expr.formula, + operand_names: expr.operands.clone(), + operands: expr.operands, + } +} + struct HammingWeightClaimRow { hamming_factor: String, booleanity: String, @@ -163,6 +183,7 @@ struct HammingWeightClaimRow { fn compact_hamming_weight_input_claim( field_exprs: &mut Vec, + value_exprs: &mut Vec, claims: &mut [Stage7SumcheckClaimPlan], opening_inputs: &[Stage7OpeningInputPlan], ) -> Result<(), EmitError> { @@ -196,7 +217,7 @@ fn compact_hamming_weight_input_claim( operands.extend(rows.iter().map(|row| row.virtualization.clone())); field_exprs.retain(|expr| !is_hamming_weight_input_claim_expr(&expr.symbol)); - field_exprs.push(Stage7FieldExprPlan { + value_exprs.push(Stage7ValueExprPlan { symbol: compact_symbol.to_owned(), kind: "op".to_owned(), formula: power_strided_weighted_sum_formula(row_count, 3, &[], &[], &[0, 1, 2]), @@ -410,6 +431,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_input = Stage7OpeningInputPlan, field_constant = Stage7FieldConstantPlan, field_expr = Stage7FieldExprPlan, + value_expr = Stage7ValueExprPlan, claim = Stage7SumcheckClaimPlan, batch = Stage7SumcheckBatchPlan, driver = Stage7SumcheckDriverPlan, @@ -452,6 +474,7 @@ impl Stage7CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); + let mut value_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -779,17 +802,24 @@ impl Stage7CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if is_verifier { - compact_hamming_weight_input_claim(&mut field_exprs, &mut claims, &opening_inputs)?; - field_exprs.extend( - verifier_relation_outputs::lower_eval_family_output_to_weighted_sum( - "stage7", - "jolt.stage7.hamming_weight_claim_reduction", - &mut relation_output_eval_families, - &mut relation_output_asts, - )? - .into_iter() - .map(stage7_relation_output_expr), - ); + compact_hamming_weight_input_claim( + &mut field_exprs, + &mut value_exprs, + &mut claims, + &opening_inputs, + )?; + for expr in verifier_relation_outputs::lower_eval_family_output_to_weighted_sum( + "stage7", + "jolt.stage7.hamming_weight_claim_reduction", + &mut relation_output_eval_families, + &mut relation_output_asts, + )? { + if ValueExprKind::from_cpu_attr(&expr.formula).is_ok() { + value_exprs.push(stage7_value_expr(expr)); + } else { + field_exprs.push(stage7_relation_output_expr(expr)); + } + } } if role == Role::Prover { verifier_relation_outputs::prune_output_only_field_exprs( @@ -824,6 +854,7 @@ impl Stage7CpuProgram { opening_inputs, field_constants, field_exprs, + value_exprs, kernels, claims, batches, @@ -932,6 +963,24 @@ impl Stage7CpuProgram { } } } + for expr in &self.value_exprs { + verify_count( + "value expr operands", + &expr.symbol, + expr.operand_names.len(), + expr.operands.len(), + )?; + let _kind = ValueExprKind::from_cpu_attr(&expr.formula) + .map_err(|error| EmitError::new(error.to_string()))?; + for operand in &expr.operands { + if !field_values.contains(operand) { + return Err(EmitError::new(format!( + "value expr @{} references missing field value @{operand}", + expr.symbol + ))); + } + } + } for claim in &self.claims { if !field_values.contains(&claim.claim_value) { return Err(EmitError::new(format!( @@ -1601,6 +1650,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage7ClaimKind, FieldConstantPlan as Stage7FieldConstantPlan, FieldExprKind as Stage7FieldExprKind, FieldExprPlan as Stage7FieldExprPlan, + ValueExprKind as Stage7ValueExprKind, + ValueExprPlan as Stage7ValueExprPlan, KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan, OpeningClaimEqualityPlan as Stage7OpeningClaimEqualityPlan, OpeningClaimPlan as Stage7OpeningClaimPlan, OpeningInputPlan as Stage7OpeningInputPlan, @@ -1664,6 +1715,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); } else { "" }; + let value_exprs_field = if self.role == Role::Verifier { + " value_exprs: STAGE7_VALUE_EXPRS,\n" + } else { + "" + }; push_format( &mut source, format_args!( @@ -1676,6 +1732,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); \x20 opening_inputs: STAGE7_OPENING_INPUTS,\n\ \x20 field_constants: STAGE7_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE7_FIELD_EXPRS,\n\ + {value_exprs_field}\ \x20 kernels: STAGE7_KERNELS,\n\ \x20 claims: STAGE7_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE7_SUMCHECK_BATCHES,\n\ @@ -1714,6 +1771,9 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); source.push_str(&self.emit_opening_input_constants()?); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); + if self.role == Role::Verifier { + source.push_str(&self.emit_value_expr_constants()?); + } Ok(source) } @@ -1904,6 +1964,17 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); Ok(source) } + fn emit_value_expr_constants(&self) -> Result { + let plan = self.verifier_plan()?; + Ok(verifier_plan::emit_value_expr_constants_chunked( + "Stage7", + "STAGE7", + "stage7_value_expr", + &plan.value_exprs, + 8, + )) + } + fn emit_kernel_constants(&self) -> String { let kernels = self .kernels @@ -2488,7 +2559,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage7Error::from)?; artifacts.challenge_vectors.push(Stage7ChallengeVector { symbol: squeeze.symbol, @@ -2566,6 +2637,7 @@ where program.claims, program.batches, program.field_exprs, + program.value_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -2618,7 +2690,7 @@ fn observe_stage7_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage7Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2666,6 +2738,7 @@ fn expected_batched_output_claim( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index b30da45b38..0c14c65aad 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -256,8 +256,6 @@ pub(crate) enum FieldExprKind { Mul, Sum, Product, - FieldVectorSum, - FieldVectorProduct, Neg, Pow(usize), LagrangeBasisEval { @@ -265,6 +263,12 @@ pub(crate) enum FieldExprKind { domain_size: usize, index: usize, }, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum ValueExprKind { + FieldVectorSum, + FieldVectorProduct, PowerStridedWeightedSum { row_count: usize, power_stride: usize, @@ -283,14 +287,9 @@ impl FieldExprKind { "field.mul" => Ok(Self::Mul), "field.sum" => Ok(Self::Sum), "field.product" => Ok(Self::Product), - "field_vector.sum" => Ok(Self::FieldVectorSum), - "field_vector.product" => Ok(Self::FieldVectorProduct), "field.neg" => Ok(Self::Neg), value if value.starts_with("field.pow:") => parse_pow(value), value if value.starts_with("poly.lagrange_basis_eval:") => parse_lagrange(value), - value if value.starts_with("field.power_strided_weighted_sum:") => { - parse_power_strided_weighted_sum(value) - } _ => Err(RustTargetPlanError::unsupported( "field expression formula", value, @@ -306,8 +305,6 @@ impl FieldExprKind { Self::Mul => "Mul".to_owned(), Self::Sum => "Sum".to_owned(), Self::Product => "Product".to_owned(), - Self::FieldVectorSum => "FieldVectorSum".to_owned(), - Self::FieldVectorProduct => "FieldVectorProduct".to_owned(), Self::Neg => "Neg".to_owned(), Self::Pow(exponent) => format!("Pow({exponent})"), Self::LagrangeBasisEval { @@ -315,6 +312,29 @@ impl FieldExprKind { domain_size, index, } => format!("LagrangeBasisEval({domain_start}, {domain_size}, {index})"), + } + } +} + +impl ValueExprKind { + pub(crate) fn from_cpu_attr(value: &str) -> Result { + match value { + "field_vector.sum" => Ok(Self::FieldVectorSum), + "field_vector.product" => Ok(Self::FieldVectorProduct), + value if value.starts_with("field.power_strided_weighted_sum:") => { + parse_power_strided_weighted_sum(value) + } + _ => Err(RustTargetPlanError::unsupported( + "value expression formula", + value, + )), + } + } + + pub(crate) fn rust_variant_expr(&self) -> String { + match self { + Self::FieldVectorSum => "FieldVectorSum".to_owned(), + Self::FieldVectorProduct => "FieldVectorProduct".to_owned(), Self::PowerStridedWeightedSum { row_count, power_stride, @@ -412,7 +432,7 @@ fn parse_lagrange(value: &str) -> Result { }) } -fn parse_power_strided_weighted_sum(value: &str) -> Result { +fn parse_power_strided_weighted_sum(value: &str) -> Result { let spec = value .strip_prefix("field.power_strided_weighted_sum:") .ok_or_else(|| RustTargetPlanError::unsupported("field expression formula", value))?; @@ -430,7 +450,7 @@ fn parse_power_strided_weighted_sum(value: &str) -> Result() .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; - Ok(FieldExprKind::PowerStridedWeightedSum { + Ok(ValueExprKind::PowerStridedWeightedSum { row_count, power_stride, value_term_offsets: parse_usize_list(value_offsets, value)?, @@ -495,7 +515,7 @@ fn usize_slice_expr(values: &[usize]) -> String { mod tests { use super::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode, - ProgramStepKind, TranscriptSqueezeKind, + ProgramStepKind, TranscriptSqueezeKind, ValueExprKind, }; #[test] @@ -540,14 +560,6 @@ mod tests { FieldExprKind::from_cpu_attr("field.product").ok(), Some(FieldExprKind::Product) ); - assert_eq!( - FieldExprKind::from_cpu_attr("field_vector.sum").ok(), - Some(FieldExprKind::FieldVectorSum) - ); - assert_eq!( - FieldExprKind::from_cpu_attr("field_vector.product").ok(), - Some(FieldExprKind::FieldVectorProduct) - ); assert_eq!( FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:-1:3:2").ok(), Some(FieldExprKind::LagrangeBasisEval { @@ -556,9 +568,24 @@ mod tests { index: 2, }) ); + assert!(FieldExprKind::from_cpu_attr("field_vector.sum").is_err()); + assert!(FieldExprKind::from_cpu_attr("field.pow:nope").is_err()); + assert!(FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:1:2").is_err()); + } + + #[test] + fn parses_value_expr_kinds() { + assert_eq!( + ValueExprKind::from_cpu_attr("field_vector.sum").ok(), + Some(ValueExprKind::FieldVectorSum) + ); + assert_eq!( + ValueExprKind::from_cpu_attr("field_vector.product").ok(), + Some(ValueExprKind::FieldVectorProduct) + ); assert_eq!( - FieldExprKind::from_cpu_attr("field.power_strided_weighted_sum:39:3:0:1:2").ok(), - Some(FieldExprKind::PowerStridedWeightedSum { + ValueExprKind::from_cpu_attr("field.power_strided_weighted_sum:39:3:0:1:2").ok(), + Some(ValueExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: vec![0], @@ -566,9 +593,7 @@ mod tests { row_term_offsets: vec![2], }) ); - assert!(FieldExprKind::from_cpu_attr("field.pow:nope").is_err()); - assert!(FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:1:2").is_err()); - assert!(FieldExprKind::from_cpu_attr("field.power_strided_weighted_sum:1:2:0").is_err()); + assert!(ValueExprKind::from_cpu_attr("field.power_strided_weighted_sum:1:2:0").is_err()); } #[test] @@ -587,7 +612,7 @@ mod tests { "LagrangeBasisEval(-1, 3, 0)" ); assert_eq!( - FieldExprKind::PowerStridedWeightedSum { + ValueExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: vec![0], diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index ca49bec254..4901a94567 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -4,7 +4,7 @@ use std::fmt::Write as _; use crate::emit::rust::EmitError; use crate::protocols::jolt::rust_target_plan::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, ProgramStepKind, - RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, + RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, ValueExprKind, }; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_relation_outputs::{ @@ -133,6 +133,27 @@ impl VerifierFieldExprPlan { } } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierValueExprPlan { + pub(crate) symbol: String, + pub(crate) kind: ValueExprKind, + pub(crate) operands: Vec, +} + +impl VerifierValueExprPlan { + pub(crate) fn from_cpu( + symbol: &str, + formula: &str, + operands: &[String], + ) -> Result { + Ok(Self { + symbol: symbol.to_owned(), + kind: ValueExprKind::from_cpu_attr(formula).map_err(plan_error)?, + operands: operands.to_vec(), + }) + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierSumcheckEvalPlan { pub(crate) symbol: String, @@ -258,6 +279,7 @@ pub(crate) struct VerifierStagePlan { pub(crate) opening_inputs: Vec, pub(crate) field_constants: Vec, pub(crate) field_exprs: Vec, + pub(crate) value_exprs: Vec, pub(crate) claims: Vec, pub(crate) batches: Vec, pub(crate) drivers: Vec, @@ -349,6 +371,10 @@ impl VerifierStagePlan { self.field_exprs.iter().map(|expr| &expr.symbol), VerifierScalarSourceKind::FieldExpr, ); + values.extend( + self.value_exprs.iter().map(|expr| &expr.symbol), + VerifierScalarSourceKind::ValueExpr, + ); values.extend( self.relation_outputs .iter() @@ -460,6 +486,12 @@ pub(crate) trait VerifierFieldExprSource { fn operands(&self) -> &[String]; } +pub(crate) trait VerifierValueExprSource { + fn symbol(&self) -> &str; + fn formula(&self) -> &str; + fn operands(&self) -> &[String]; +} + pub(crate) trait VerifierSumcheckEvalSource { fn symbol(&self) -> &str; fn source(&self) -> &str; @@ -572,6 +604,7 @@ pub(crate) trait VerifierStagePlanSource { type OpeningInput: VerifierOpeningInputSource; type FieldConstant: VerifierFieldConstantSource; type FieldExpr: VerifierFieldExprSource; + type ValueExpr: VerifierValueExprSource; type Claim: VerifierSumcheckClaimSource; type Batch: VerifierSumcheckBatchSource; type Driver: VerifierSumcheckDriverSource; @@ -589,6 +622,7 @@ pub(crate) trait VerifierStagePlanSource { fn opening_inputs(&self) -> &[Self::OpeningInput]; fn field_constants(&self) -> &[Self::FieldConstant]; fn field_exprs(&self) -> &[Self::FieldExpr]; + fn value_exprs(&self) -> &[Self::ValueExpr]; fn claims(&self) -> &[Self::Claim]; fn batches(&self) -> &[Self::Batch]; fn drivers(&self) -> &[Self::Driver]; @@ -670,6 +704,13 @@ where VerifierFieldExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands()) }) .collect::, EmitError>>()?, + value_exprs: source + .value_exprs() + .iter() + .map(|expr| { + VerifierValueExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands()) + }) + .collect::, EmitError>>()?, claims: source .claims() .iter() @@ -864,6 +905,7 @@ macro_rules! impl_verifier_plan_source_traits { opening_input = $opening_input:ty, field_constant = $field_constant:ty, field_expr = $field_expr:ty, + value_expr = $value_expr:ty, claim = $claim:ty, batch = $batch:ty, driver = $driver:ty, @@ -888,6 +930,7 @@ macro_rules! impl_verifier_plan_source_traits { type OpeningInput = $opening_input; type FieldConstant = $field_constant; type FieldExpr = $field_expr; + type ValueExpr = $value_expr; type Claim = $claim; type Batch = $batch; type Driver = $driver; @@ -909,6 +952,7 @@ macro_rules! impl_verifier_plan_source_traits { fn opening_inputs(&self) -> &[Self::OpeningInput] { &self.opening_inputs } fn field_constants(&self) -> &[Self::FieldConstant] { &self.field_constants } fn field_exprs(&self) -> &[Self::FieldExpr] { &self.field_exprs } + fn value_exprs(&self) -> &[Self::ValueExpr] { &self.value_exprs } fn claims(&self) -> &[Self::Claim] { &self.claims } fn batches(&self) -> &[Self::Batch] { &self.batches } fn drivers(&self) -> &[Self::Driver] { &self.drivers } @@ -994,6 +1038,12 @@ macro_rules! impl_verifier_plan_source_traits { fn operands(&self) -> &[String] { &self.operands } } + impl $crate::protocols::jolt::verifier_plan::VerifierValueExprSource for $value_expr { + fn symbol(&self) -> &str { &self.symbol } + fn formula(&self) -> &str { &self.formula } + fn operands(&self) -> &[String] { &self.operands } + } + impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckEvalSource for $eval { fn symbol(&self) -> &str { &self.symbol } fn source(&self) -> &str { &self.source } @@ -1210,6 +1260,13 @@ pub(crate) fn field_expr_kind_expr(stage_type_prefix: &str, kind: &FieldExprKind ) } +pub(crate) fn value_expr_kind_expr(stage_type_prefix: &str, kind: &ValueExprKind) -> String { + format!( + "{stage_type_prefix}ValueExprKind::{}", + kind.rust_variant_expr() + ) +} + pub(crate) fn sumcheck_point_order_expr(point_order: SumcheckPointOrder) -> String { format!( "bolt_verifier_runtime::SumcheckPointOrder::{}", @@ -1341,6 +1398,28 @@ pub(crate) fn emit_field_expr_constants( ) } +pub(crate) fn emit_value_expr_constants( + stage_type_prefix: &str, + const_prefix: &str, + exprs: &[VerifierValueExprPlan], +) -> String { + let exprs = exprs + .iter() + .map(|expr| { + format!( + " {stage_type_prefix}ValueExprPlan {{ symbol: {}, kind: {}, operands: {} }},", + rust_str(&expr.symbol), + value_expr_kind_expr(stage_type_prefix, &expr.kind), + rust_str_slice_expr(&expr.operands), + ) + }) + .collect::>() + .join("\n"); + format!( + "pub const {const_prefix}_VALUE_EXPRS: &[{stage_type_prefix}ValueExprPlan] = &[\n{exprs}\n];\n" + ) +} + pub(crate) fn emit_field_expr_constants_chunked( stage_type_prefix: &str, const_prefix: &str, @@ -1372,6 +1451,37 @@ pub(crate) fn emit_field_expr_constants_chunked( ) } +pub(crate) fn emit_value_expr_constants_chunked( + stage_type_prefix: &str, + const_prefix: &str, + helper_name: &str, + exprs: &[VerifierValueExprPlan], + chunk_size: usize, +) -> String { + let rows = exprs + .chunks(chunk_size) + .map(|chunk| { + let exprs = chunk + .iter() + .map(|expr| { + format!( + "{helper_name}({}, {}, {})", + rust_str(&expr.symbol), + value_expr_kind_expr(stage_type_prefix, &expr.kind), + rust_str_slice_expr(&expr.operands) + ) + }) + .collect::>() + .join(", "); + format!(" {exprs},") + }) + .collect::>() + .join("\n"); + format!( + "const fn {helper_name}(symbol: &'static str, kind: {stage_type_prefix}ValueExprKind, operands: &'static [&'static str]) -> {stage_type_prefix}ValueExprPlan {{\n {stage_type_prefix}ValueExprPlan {{ symbol, kind, operands }}\n}}\n\n#[rustfmt::skip]\npub const {const_prefix}_VALUE_EXPRS: &[{stage_type_prefix}ValueExprPlan] = &[\n{rows}\n];\n" + ) +} + pub(crate) fn emit_sumcheck_claim_constants( stage_type_prefix: &str, const_prefix: &str, diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index c13826f333..ad564d34ef 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -8,6 +8,7 @@ pub enum VerifierScalarSourceKind { FieldConstant, TranscriptScalar, FieldExpr, + ValueExpr, PointDerived, SumcheckEval, StructuredPolynomialEval, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 18e474a092..55cbaca4fb 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -2083,20 +2083,20 @@ fn stage7_rust_targets_extract_and_compile() { "stage7.hamming_weight_claim_reduction.input.claim_expr" ); let input_expr = verifier_program - .field_exprs + .value_exprs .iter() .find(|expr| expr.symbol == "stage7.hamming_weight_claim_reduction.input.claim_expr") - .expect("stage7 hamming input claim is lowered to a field expression"); + .expect("stage7 hamming input claim is lowered to a value expression"); assert_eq!( input_expr.formula, format!("field.power_strided_weighted_sum:{total_ra}:3:_:_:0,1,2") ); assert_eq!(input_expr.operands.len(), 1 + total_ra + 3 * total_ra); let output_expr = verifier_program - .field_exprs + .value_exprs .iter() .find(|expr| expr.symbol == "stage7.hamming_weight_claim_reduction.output.claim_expr") - .expect("stage7 hamming output is lowered to a field expression"); + .expect("stage7 hamming output is lowered to a value expression"); assert_eq!( output_expr.formula, format!("field.power_strided_weighted_sum:{total_ra}:3:0:1:2") @@ -2166,6 +2166,9 @@ fn stage7_rust_targets_extract_and_compile() { .source .contains("STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS")); assert!(verifier_source + .source + .contains("Stage7ValueExprKind::PowerStridedWeightedSum")); + assert!(!verifier_source .source .contains("Stage7FieldExprKind::PowerStridedWeightedSum")); assert!(!verifier_source diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index be599e2712..a6e4a503c3 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -23,6 +23,16 @@ macro_rules! stage_field_expr { }; } +macro_rules! stage_value_expr { + (generated, $module:ident, $value_expr:ident, $plan:ident) => { + $module::$value_expr { + symbol: super::leak_str(&$plan.symbol), + kind: super::generated_value_expr_kind($plan.formula.as_str()), + operands: super::leak_str_slice(&$plan.operands), + } + }; +} + macro_rules! stage_optional_relation_kind { (kernel, $value:expr) => { $value.map(super::leak_str) @@ -270,8 +280,6 @@ fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKin "field.mul" => bolt_verifier_runtime::FieldExprKind::Mul, "field.sum" => bolt_verifier_runtime::FieldExprKind::Sum, "field.product" => bolt_verifier_runtime::FieldExprKind::Product, - "field_vector.sum" => bolt_verifier_runtime::FieldExprKind::FieldVectorSum, - "field_vector.product" => bolt_verifier_runtime::FieldExprKind::FieldVectorProduct, "field.neg" => bolt_verifier_runtime::FieldExprKind::Neg, value if value.starts_with("field.pow:") => { let exponent = value @@ -297,6 +305,19 @@ fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKin parts[2].parse::().expect("lagrange index is usize"), ) } + value => panic!("unsupported generated field expression kind `{value}`"), + } +} + +#[expect( + clippy::expect_used, + clippy::panic, + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier value expression tag" +)] +fn generated_value_expr_kind(value: &str) -> bolt_verifier_runtime::ValueExprKind { + match value { + "field_vector.sum" => bolt_verifier_runtime::ValueExprKind::FieldVectorSum, + "field_vector.product" => bolt_verifier_runtime::ValueExprKind::FieldVectorProduct, value if value.starts_with("field.power_strided_weighted_sum:") => { let spec = value .strip_prefix("field.power_strided_weighted_sum:") @@ -306,7 +327,7 @@ fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKin parts.len() == 5, "power-strided weighted expression has five fields" ); - bolt_verifier_runtime::FieldExprKind::PowerStridedWeightedSum { + bolt_verifier_runtime::ValueExprKind::PowerStridedWeightedSum { row_count: parts[0] .parse::() .expect("power-strided weighted row count is usize"), @@ -318,7 +339,7 @@ fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKin row_term_offsets: leak_slice(parse_usize_list(parts[4])), } } - value => panic!("unsupported generated field expression kind `{value}`"), + value => panic!("unsupported generated value expression kind `{value}`"), } } @@ -497,6 +518,8 @@ macro_rules! define_stage_adapter_impl { $(, role = $role_field:ident)? $(, transcript_absorb_bytes = $absorb:ident)? $(, kernels = $kernel:ident)? + $(, value_expr = $value_expr:ident)? + $(, empty_value_exprs = $empty_value_exprs:ident)? $(, point_zeros = $point_zero:ident)? $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? @@ -581,6 +604,21 @@ macro_rules! define_stage_adapter_impl { .collect(), ), $( + value_exprs: super::leak_slice( + program + .value_exprs + .iter() + .map(|plan| stage_value_expr!($mode, $module, $value_expr, plan)) + .collect(), + ), + )? + $( + value_exprs: { + let _ = stringify!($empty_value_exprs); + &[] + }, + )? + $( kernels: super::leak_slice( program .kernels @@ -814,6 +852,8 @@ macro_rules! define_stage_adapter { $opening_equality:ident, $opening_batch:ident $(, point_zero = $point_zero:ident)? + $(, value_expr = $value_expr:ident)? + $(, empty_value_exprs = $empty_value_exprs:ident)? $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? ) => { @@ -841,6 +881,8 @@ macro_rules! define_stage_adapter { role = role, transcript_absorb_bytes = $absorb, kernels = $kernel + $(, value_expr = $value_expr)? + $(, empty_value_exprs = $empty_value_exprs)? $(, point_zeros = $point_zero)? $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? $(, empty_relation_outputs = $empty_relation_outputs)? @@ -873,6 +915,8 @@ macro_rules! define_stage_adapter_no_absorb { $opening_claim:ident, $opening_batch:ident $(, kernels = $kernel:ident)? + $(, value_expr = $value_expr:ident)? + $(, empty_value_exprs = $empty_value_exprs:ident)? $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? @@ -899,6 +943,8 @@ macro_rules! define_stage_adapter_no_absorb { $opening_claim, $opening_batch $(, kernels = $kernel)? + $(, value_expr = $value_expr)? + $(, empty_value_exprs = $empty_value_exprs)? $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? $(, empty_relation_outputs = $empty_relation_outputs)? $(, opening_equalities = $opening_equality)? diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs index 517e934a68..6a449b9766 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs @@ -21,5 +21,6 @@ define_stage_adapter_no_absorb!( Stage2PointSlicePlan, Stage2PointConcatPlan, Stage2OpeningClaimPlan, - Stage2OpeningBatchPlan + Stage2OpeningBatchPlan, + empty_value_exprs = Stage2ValueExprPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs index 223ff3f2da..81436a8b72 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs @@ -22,6 +22,7 @@ define_stage_adapter_no_absorb!( Stage3PointConcatPlan, Stage3OpeningClaimPlan, Stage3OpeningBatchPlan, + value_expr = Stage3ValueExprPlan, relation_outputs = Stage3RelationOutputPlan, relation_output_values = Stage3StructuredPolynomialEvalPlan, opening_equalities = Stage3OpeningClaimEqualityPlan diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs index 08e83ed2de..1b3cb4cad0 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs @@ -25,6 +25,7 @@ define_stage_adapter!( Stage4OpeningClaimPlan, Stage4OpeningClaimEqualityPlan, Stage4OpeningBatchPlan, + value_expr = Stage4ValueExprPlan, relation_outputs = Stage4RelationOutputPlan, relation_output_values = Stage4StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs index 83b8661dad..f026b3ca15 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs @@ -25,6 +25,7 @@ define_stage_adapter!( Stage5OpeningClaimPlan, Stage5OpeningClaimEqualityPlan, Stage5OpeningBatchPlan, + value_expr = Stage5ValueExprPlan, relation_outputs = Stage5RelationOutputPlan, relation_output_values = Stage5StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs index 533fc349e0..aad92a4e51 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs @@ -26,6 +26,7 @@ define_stage_adapter!( Stage6OpeningClaimEqualityPlan, Stage6OpeningBatchPlan, point_zero = Stage6PointZeroPlan, + value_expr = Stage6ValueExprPlan, relation_outputs = Stage6RelationOutputPlan, relation_output_values = Stage6StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs index ce4395238a..78f377d3fa 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs @@ -26,6 +26,7 @@ define_stage_adapter!( Stage7OpeningClaimEqualityPlan, Stage7OpeningBatchPlan, point_zero = Stage7PointZeroPlan, + value_expr = Stage7ValueExprPlan, relation_outputs = Stage7RelationOutputPlan, relation_output_values = Stage7StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index b946c9041a..eb8ea2d9c1 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -25,6 +25,7 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage2ClaimKind, FieldConstantPlan as Stage2FieldConstantPlan, FieldExprKind as Stage2FieldExprKind, FieldExprPlan as Stage2FieldExprPlan, + ValueExprPlan as Stage2ValueExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, OpeningInputPlan as Stage2OpeningInputPlan, PointConcatPlan as Stage2PointConcatPlan, PointSlicePlan as Stage2PointSlicePlan, ProgramStepKind as Stage2ProgramStepKind, @@ -144,6 +145,7 @@ pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LeftInstructionInput", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.RightOperand", "stage2.instruction_lookup.term.LeftInstructionInput"] }, Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.LeftInstructionInput", "stage2.instruction_lookup.term.RightInstructionInput"] }, ]; +pub const STAGE2_VALUE_EXPRS: &[Stage2ValueExprPlan] = &[]; pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[ Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr" }, Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some(Stage2RelationKind::Stage2RamReadWrite), claim_value: "stage2.ram_read_write.claim_expr" }, @@ -246,6 +248,7 @@ pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan opening_inputs: STAGE2_OPENING_INPUTS, field_constants: STAGE2_FIELD_CONSTANTS, field_exprs: STAGE2_FIELD_EXPRS, + value_exprs: STAGE2_VALUE_EXPRS, claims: STAGE2_SUMCHECK_CLAIMS, batches: STAGE2_SUMCHECK_BATCHES, drivers: STAGE2_SUMCHECK_DRIVERS, @@ -638,7 +641,7 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, ) -> Result<(), VerifyStage2Error> { self.0 - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage2Error::from) } diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 239c7f7c46..d15be64412 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -25,6 +25,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage3ClaimKind, FieldConstantPlan as Stage3FieldConstantPlan, FieldExprKind as Stage3FieldExprKind, FieldExprPlan as Stage3FieldExprPlan, + ValueExprKind as Stage3ValueExprKind, + ValueExprPlan as Stage3ValueExprPlan, OpeningBatchPlan as Stage3OpeningBatchPlan, OpeningClaimEqualityPlan as Stage3OpeningClaimEqualityPlan, OpeningClaimPlan as Stage3OpeningClaimPlan, OpeningInputPlan as Stage3OpeningInputPlan, @@ -135,6 +137,9 @@ pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[ Stage3FieldExprPlan { symbol: "stage3.registers.output.partial.RdWriteValueRs1Value", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers_claim_reduction.eval.RdWriteValue", "stage3.registers.output.term.Rs1Value"] }, Stage3FieldExprPlan { symbol: "stage3.registers.output.weighted_register_values", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers.output.partial.RdWriteValueRs1Value", "stage3.registers.output.term.Rs2Value"] }, Stage3FieldExprPlan { symbol: "stage3.registers.output.claim_expr", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.output.eq.RdWriteValue", "stage3.registers.output.weighted_register_values"] }, +]; +pub const STAGE3_VALUE_EXPRS: &[Stage3ValueExprPlan] = &[ + ]; pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[ Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr" }, @@ -230,6 +235,7 @@ pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan opening_inputs: STAGE3_OPENING_INPUTS, field_constants: STAGE3_FIELD_CONSTANTS, field_exprs: STAGE3_FIELD_EXPRS, + value_exprs: STAGE3_VALUE_EXPRS, claims: STAGE3_SUMCHECK_CLAIMS, batches: STAGE3_SUMCHECK_BATCHES, drivers: STAGE3_SUMCHECK_DRIVERS, @@ -327,7 +333,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage3Error::from)?; artifacts.challenge_vectors.push(Stage3ChallengeVector { symbol: squeeze.symbol, @@ -394,6 +400,7 @@ where program.claims, program.batches, program.field_exprs, + program.value_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -446,7 +453,7 @@ fn observe_stage3_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage3Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -486,6 +493,7 @@ fn expected_batched_output_claim( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 29d018f70b..a7ca92d8d0 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -23,6 +23,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage4ClaimKind, FieldConstantPlan as Stage4FieldConstantPlan, FieldExprKind as Stage4FieldExprKind, FieldExprPlan as Stage4FieldExprPlan, + ValueExprKind as Stage4ValueExprKind, + ValueExprPlan as Stage4ValueExprPlan, KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan, OpeningClaimEqualityPlan as Stage4OpeningClaimEqualityPlan, OpeningClaimPlan as Stage4OpeningClaimPlan, OpeningInputPlan as Stage4OpeningInputPlan, @@ -114,6 +116,9 @@ pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[ Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.lt_plus_gamma", kind: Stage4FieldExprKind::Add, operands: &["stage4.ram_val_check.output.lt.RamValCycle", "stage4.ram_val_check.gamma"] }, Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.term.RamIncRamRa", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.eval.RamInc", "stage4.ram_val_check.eval.RamRa"] }, Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.claim_expr", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.output.term.RamIncRamRa", "stage4.ram_val_check.output.lt_plus_gamma"] }, +]; +pub const STAGE4_VALUE_EXPRS: &[Stage4ValueExprPlan] = &[ + ]; pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[ @@ -193,6 +198,7 @@ pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { opening_inputs: STAGE4_OPENING_INPUTS, field_constants: STAGE4_FIELD_CONSTANTS, field_exprs: STAGE4_FIELD_EXPRS, + value_exprs: STAGE4_VALUE_EXPRS, kernels: STAGE4_KERNELS, claims: STAGE4_SUMCHECK_CLAIMS, batches: STAGE4_SUMCHECK_BATCHES, @@ -293,7 +299,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage4Error::from)?; artifacts.challenge_vectors.push(Stage4ChallengeVector { symbol: squeeze.symbol, @@ -371,6 +377,7 @@ where program.claims, program.batches, program.field_exprs, + program.value_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -426,7 +433,7 @@ fn observe_stage4_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage4Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -466,6 +473,7 @@ fn expected_batched_output_claim( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index a6eff0991a..3e009e9c2a 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -24,6 +24,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage5ClaimKind, FieldConstantPlan as Stage5FieldConstantPlan, FieldExprKind as Stage5FieldExprKind, FieldExprPlan as Stage5FieldExprPlan, + ValueExprKind as Stage5ValueExprKind, + ValueExprPlan as Stage5ValueExprPlan, KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan, OpeningClaimEqualityPlan as Stage5OpeningClaimEqualityPlan, OpeningClaimPlan as Stage5OpeningClaimPlan, OpeningInputPlan as Stage5OpeningInputPlan, @@ -152,7 +154,6 @@ pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[ Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_39", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_40", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.product.LookupTableValues", kind: Stage5FieldExprKind::Sum, operands: &["stage5.instruction_read_raf.output.term.LookupTableValue_0", "stage5.instruction_read_raf.output.term.LookupTableValue_1", "stage5.instruction_read_raf.output.term.LookupTableValue_2", "stage5.instruction_read_raf.output.term.LookupTableValue_3", "stage5.instruction_read_raf.output.term.LookupTableValue_4", "stage5.instruction_read_raf.output.term.LookupTableValue_5", "stage5.instruction_read_raf.output.term.LookupTableValue_6", "stage5.instruction_read_raf.output.term.LookupTableValue_7", "stage5.instruction_read_raf.output.term.LookupTableValue_8", "stage5.instruction_read_raf.output.term.LookupTableValue_9", "stage5.instruction_read_raf.output.term.LookupTableValue_10", "stage5.instruction_read_raf.output.term.LookupTableValue_11", "stage5.instruction_read_raf.output.term.LookupTableValue_12", "stage5.instruction_read_raf.output.term.LookupTableValue_13", "stage5.instruction_read_raf.output.term.LookupTableValue_14", "stage5.instruction_read_raf.output.term.LookupTableValue_15", "stage5.instruction_read_raf.output.term.LookupTableValue_16", "stage5.instruction_read_raf.output.term.LookupTableValue_17", "stage5.instruction_read_raf.output.term.LookupTableValue_18", "stage5.instruction_read_raf.output.term.LookupTableValue_19", "stage5.instruction_read_raf.output.term.LookupTableValue_20", "stage5.instruction_read_raf.output.term.LookupTableValue_21", "stage5.instruction_read_raf.output.term.LookupTableValue_22", "stage5.instruction_read_raf.output.term.LookupTableValue_23", "stage5.instruction_read_raf.output.term.LookupTableValue_24", "stage5.instruction_read_raf.output.term.LookupTableValue_25", "stage5.instruction_read_raf.output.term.LookupTableValue_26", "stage5.instruction_read_raf.output.term.LookupTableValue_27", "stage5.instruction_read_raf.output.term.LookupTableValue_28", "stage5.instruction_read_raf.output.term.LookupTableValue_29", "stage5.instruction_read_raf.output.term.LookupTableValue_30", "stage5.instruction_read_raf.output.term.LookupTableValue_31", "stage5.instruction_read_raf.output.term.LookupTableValue_32", "stage5.instruction_read_raf.output.term.LookupTableValue_33", "stage5.instruction_read_raf.output.term.LookupTableValue_34", "stage5.instruction_read_raf.output.term.LookupTableValue_35", "stage5.instruction_read_raf.output.term.LookupTableValue_36", "stage5.instruction_read_raf.output.term.LookupTableValue_37", "stage5.instruction_read_raf.output.term.LookupTableValue_38", "stage5.instruction_read_raf.output.term.LookupTableValue_39", "stage5.instruction_read_raf.output.term.LookupTableValue_40"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", kind: Stage5FieldExprKind::FieldVectorProduct, operands: &["stage5.instruction_read_raf.eval.InstructionRa"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaRightLookupOperand", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.point_value.RightLookupOperand"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.output.term.GammaRightLookupOperand"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.RafFlagLeftPlusGammaRight", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.eval.InstructionRafFlag", "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight"] }, @@ -165,6 +166,9 @@ pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[ Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.EqRa", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.output.eq.LookupOutputCycle", "stage5.instruction_read_raf.output.product.InstructionRa"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.output.partial.EqRa", "stage5.instruction_read_raf.output.partial.LookupOrRaf"] }, ]; +pub const STAGE5_VALUE_EXPRS: &[Stage5ValueExprPlan] = &[ + Stage5ValueExprPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", kind: Stage5ValueExprKind::FieldVectorProduct, operands: &["stage5.instruction_read_raf.eval.InstructionRa"] }, +]; pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[ ]; @@ -426,6 +430,7 @@ pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { opening_inputs: STAGE5_OPENING_INPUTS, field_constants: STAGE5_FIELD_CONSTANTS, field_exprs: STAGE5_FIELD_EXPRS, + value_exprs: STAGE5_VALUE_EXPRS, kernels: STAGE5_KERNELS, claims: STAGE5_SUMCHECK_CLAIMS, batches: STAGE5_SUMCHECK_BATCHES, @@ -526,7 +531,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage5Error::from)?; artifacts.challenge_vectors.push(Stage5ChallengeVector { symbol: squeeze.symbol, @@ -604,6 +609,7 @@ where program.claims, program.batches, program.field_exprs, + program.value_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -660,7 +666,7 @@ fn observe_stage5_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage5Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -712,6 +718,7 @@ fn expected_batched_output_claim( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, @@ -726,6 +733,7 @@ fn expected_batched_output_claim( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 98ba61d1d5..16b8116f22 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -24,6 +24,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage6ClaimKind, FieldConstantPlan as Stage6FieldConstantPlan, FieldExprKind as Stage6FieldExprKind, FieldExprPlan as Stage6FieldExprPlan, + ValueExprKind as Stage6ValueExprKind, + ValueExprPlan as Stage6ValueExprPlan, KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan, OpeningClaimEqualityPlan as Stage6OpeningClaimEqualityPlan, OpeningClaimPlan as Stage6OpeningClaimPlan, OpeningInputPlan as Stage6OpeningInputPlan, @@ -317,7 +319,15 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.hamming_booleanity.output.term0", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.output.term0.boolean_zero", "stage6.hamming_booleanity.output.eq.LookupOutput"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.hamming_booleanity.output.term0"]), stage6_field_expr("stage6.inc_claim_reduction.output.term0", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.eq.RamIncStage2"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term1", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.gamma_pow_1", "stage6.inc_claim_reduction.output.eq.RamIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term2", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term3", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_3", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.inc_claim_reduction.output.term0", "stage6.inc_claim_reduction.output.term1", "stage6.inc_claim_reduction.output.term2", "stage6.inc_claim_reduction.output.term3"]), stage6_field_expr("stage6.ram_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3", "stage6.ram_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.ram_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.ram_ra_virtual.output.term0"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term1", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_1", "stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term2", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_2", "stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term3", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term4", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term5", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), stage6_field_expr("stage6.bytecode_read_raf.output.product.BytecodeRa", Stage6FieldExprKind::FieldVectorProduct, &["stage6.bytecode_read_raf.eval.BytecodeRa"]), stage6_field_expr("stage6.bytecode_read_raf.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.output.product.BytecodeRa"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), stage6_field_expr("stage6.bytecode_read_raf.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.output.product.BytecodeRa"]), +]; +const fn stage6_value_expr(symbol: &'static str, kind: Stage6ValueExprKind, operands: &'static [&'static str]) -> Stage6ValueExprPlan { + Stage6ValueExprPlan { symbol, kind, operands } +} + +#[rustfmt::skip] +pub const STAGE6_VALUE_EXPRS: &[Stage6ValueExprPlan] = &[ + stage6_value_expr("stage6.bytecode_read_raf.output.product.BytecodeRa", Stage6ValueExprKind::FieldVectorProduct, &["stage6.bytecode_read_raf.eval.BytecodeRa"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -686,6 +696,7 @@ pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { opening_inputs: STAGE6_OPENING_INPUTS, field_constants: STAGE6_FIELD_CONSTANTS, field_exprs: STAGE6_FIELD_EXPRS, + value_exprs: STAGE6_VALUE_EXPRS, kernels: STAGE6_KERNELS, claims: STAGE6_SUMCHECK_CLAIMS, batches: STAGE6_SUMCHECK_BATCHES, @@ -802,7 +813,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage6Error::from)?; artifacts.challenge_vectors.push(Stage6ChallengeVector { symbol: squeeze.symbol, @@ -882,6 +893,7 @@ where program.claims, program.batches, program.field_exprs, + program.value_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -945,7 +957,7 @@ fn observe_stage6_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage6Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -1038,6 +1050,7 @@ fn expected_plan_relation_output( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index ef5f908710..955af5b4bf 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -23,6 +23,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage7ClaimKind, FieldConstantPlan as Stage7FieldConstantPlan, FieldExprKind as Stage7FieldExprKind, FieldExprPlan as Stage7FieldExprPlan, + ValueExprKind as Stage7ValueExprKind, + ValueExprPlan as Stage7ValueExprPlan, KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan, OpeningClaimEqualityPlan as Stage7OpeningClaimEqualityPlan, OpeningClaimPlan as Stage7OpeningClaimPlan, OpeningInputPlan as Stage7OpeningInputPlan, @@ -167,7 +169,15 @@ const fn stage7_field_expr(symbol: &'static str, kind: Stage7FieldExprKind, oper #[rustfmt::skip] pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[ - stage7_field_expr("stage7.hamming_weight_claim_reduction.input.claim_expr", Stage7FieldExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[], shared_term_offsets: &[], row_term_offsets: &[0, 1, 2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.booleanity.InstructionRa_0", "stage7.input.stage6.booleanity.InstructionRa_1", "stage7.input.stage6.booleanity.InstructionRa_2", "stage7.input.stage6.booleanity.InstructionRa_3", "stage7.input.stage6.booleanity.InstructionRa_4", "stage7.input.stage6.booleanity.InstructionRa_5", "stage7.input.stage6.booleanity.InstructionRa_6", "stage7.input.stage6.booleanity.InstructionRa_7", "stage7.input.stage6.booleanity.InstructionRa_8", "stage7.input.stage6.booleanity.InstructionRa_9", "stage7.input.stage6.booleanity.InstructionRa_10", "stage7.input.stage6.booleanity.InstructionRa_11", "stage7.input.stage6.booleanity.InstructionRa_12", "stage7.input.stage6.booleanity.InstructionRa_13", "stage7.input.stage6.booleanity.InstructionRa_14", "stage7.input.stage6.booleanity.InstructionRa_15", "stage7.input.stage6.booleanity.InstructionRa_16", "stage7.input.stage6.booleanity.InstructionRa_17", "stage7.input.stage6.booleanity.InstructionRa_18", "stage7.input.stage6.booleanity.InstructionRa_19", "stage7.input.stage6.booleanity.InstructionRa_20", "stage7.input.stage6.booleanity.InstructionRa_21", "stage7.input.stage6.booleanity.InstructionRa_22", "stage7.input.stage6.booleanity.InstructionRa_23", "stage7.input.stage6.booleanity.InstructionRa_24", "stage7.input.stage6.booleanity.InstructionRa_25", "stage7.input.stage6.booleanity.InstructionRa_26", "stage7.input.stage6.booleanity.InstructionRa_27", "stage7.input.stage6.booleanity.InstructionRa_28", "stage7.input.stage6.booleanity.InstructionRa_29", "stage7.input.stage6.booleanity.InstructionRa_30", "stage7.input.stage6.booleanity.InstructionRa_31", "stage7.input.stage6.booleanity.BytecodeRa_0", "stage7.input.stage6.booleanity.BytecodeRa_1", "stage7.input.stage6.booleanity.BytecodeRa_2", "stage7.input.stage6.booleanity.RamRa_0", "stage7.input.stage6.booleanity.RamRa_1", "stage7.input.stage6.booleanity.RamRa_2", "stage7.input.stage6.booleanity.RamRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_0", "stage7.input.stage6.ram_ra_virtual.RamRa_1", "stage7.input.stage6.ram_ra_virtual.RamRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), stage7_field_expr("stage7.hamming_weight_claim_reduction.output.claim_expr", Stage7FieldExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), + +]; +const fn stage7_value_expr(symbol: &'static str, kind: Stage7ValueExprKind, operands: &'static [&'static str]) -> Stage7ValueExprPlan { + Stage7ValueExprPlan { symbol, kind, operands } +} + +#[rustfmt::skip] +pub const STAGE7_VALUE_EXPRS: &[Stage7ValueExprPlan] = &[ + stage7_value_expr("stage7.hamming_weight_claim_reduction.input.claim_expr", Stage7ValueExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[], shared_term_offsets: &[], row_term_offsets: &[0, 1, 2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.booleanity.InstructionRa_0", "stage7.input.stage6.booleanity.InstructionRa_1", "stage7.input.stage6.booleanity.InstructionRa_2", "stage7.input.stage6.booleanity.InstructionRa_3", "stage7.input.stage6.booleanity.InstructionRa_4", "stage7.input.stage6.booleanity.InstructionRa_5", "stage7.input.stage6.booleanity.InstructionRa_6", "stage7.input.stage6.booleanity.InstructionRa_7", "stage7.input.stage6.booleanity.InstructionRa_8", "stage7.input.stage6.booleanity.InstructionRa_9", "stage7.input.stage6.booleanity.InstructionRa_10", "stage7.input.stage6.booleanity.InstructionRa_11", "stage7.input.stage6.booleanity.InstructionRa_12", "stage7.input.stage6.booleanity.InstructionRa_13", "stage7.input.stage6.booleanity.InstructionRa_14", "stage7.input.stage6.booleanity.InstructionRa_15", "stage7.input.stage6.booleanity.InstructionRa_16", "stage7.input.stage6.booleanity.InstructionRa_17", "stage7.input.stage6.booleanity.InstructionRa_18", "stage7.input.stage6.booleanity.InstructionRa_19", "stage7.input.stage6.booleanity.InstructionRa_20", "stage7.input.stage6.booleanity.InstructionRa_21", "stage7.input.stage6.booleanity.InstructionRa_22", "stage7.input.stage6.booleanity.InstructionRa_23", "stage7.input.stage6.booleanity.InstructionRa_24", "stage7.input.stage6.booleanity.InstructionRa_25", "stage7.input.stage6.booleanity.InstructionRa_26", "stage7.input.stage6.booleanity.InstructionRa_27", "stage7.input.stage6.booleanity.InstructionRa_28", "stage7.input.stage6.booleanity.InstructionRa_29", "stage7.input.stage6.booleanity.InstructionRa_30", "stage7.input.stage6.booleanity.InstructionRa_31", "stage7.input.stage6.booleanity.BytecodeRa_0", "stage7.input.stage6.booleanity.BytecodeRa_1", "stage7.input.stage6.booleanity.BytecodeRa_2", "stage7.input.stage6.booleanity.RamRa_0", "stage7.input.stage6.booleanity.RamRa_1", "stage7.input.stage6.booleanity.RamRa_2", "stage7.input.stage6.booleanity.RamRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_0", "stage7.input.stage6.ram_ra_virtual.RamRa_1", "stage7.input.stage6.ram_ra_virtual.RamRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.claim_expr", Stage7ValueExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), ]; pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ @@ -366,6 +376,7 @@ pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan { opening_inputs: STAGE7_OPENING_INPUTS, field_constants: STAGE7_FIELD_CONSTANTS, field_exprs: STAGE7_FIELD_EXPRS, + value_exprs: STAGE7_VALUE_EXPRS, kernels: STAGE7_KERNELS, claims: STAGE7_SUMCHECK_CLAIMS, batches: STAGE7_SUMCHECK_BATCHES, @@ -475,7 +486,7 @@ where } })?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage7Error::from)?; artifacts.challenge_vectors.push(Stage7ChallengeVector { symbol: squeeze.symbol, @@ -553,6 +564,7 @@ where program.claims, program.batches, program.field_exprs, + program.value_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -605,7 +617,7 @@ fn observe_stage7_sumcheck_output( }, )?; store - .evaluate_available_field_exprs(program.field_exprs, bolt_verifier_runtime::evaluate_field_expr) + .evaluate_available_exprs(program.field_exprs, program.value_exprs) .map_err(VerifyStage7Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -653,6 +665,7 @@ fn expected_batched_output_claim( program.relation_outputs, program.relation_output_values, program.field_exprs, + program.value_exprs, store, instance, evals, &[], &[], local_point, From d2bb5f3aa2c62363e68153b434dd2ed85566c50a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 23:05:45 -0600 Subject: [PATCH 108/171] refactor(bolt): lower structured outputs as value exprs Move structured polynomial relation-output evaluation into verifier value-expression rows across Stages 3 through 7. Relation-output runtime evaluation now consumes those value rows instead of a relation_output_values side channel, and generated verifier/equivalence adapters are regenerated for the new value expression kind. Verification: - cargo check -p bolt-verifier-runtime -p bolt -p jolt-equivalence -p jolt-verifier --quiet - JOLT_UPDATE_GOLDENS=1 cargo nextest run -p bolt generated_jolt_artifacts_have_uniform_crate_layout_and_import_rules --cargo-quiet - cargo nextest run -p bolt-verifier-runtime value_store_evaluates_field_vector_exprs value_expr_evaluates_power_strided_weighted_sum relation_output_evaluates_structured_polynomial_value_exprs --cargo-quiet - cargo nextest run -p bolt rust_target_plan stage5_instruction_read_raf_plan stage6_bytecode_read_raf_plan generated_jolt_artifacts_have_uniform_crate_layout_and_import_rules --cargo-quiet - cargo nextest run -p bolt stage7_rust_targets_extract_and_compile verifier_relation_outputs --cargo-quiet - cargo nextest run -p jolt-equivalence --cargo-quiet - cargo clippy -p bolt-verifier-runtime -p bolt --all-targets -q -- -D warnings - cargo clippy -p jolt-verifier -p jolt-equivalence --all-targets -q -- -D warnings - git diff --check --- crates/bolt-verifier-runtime/src/lib.rs | 216 ++++++++++++---- .../src/protocols/jolt/emit/rust/stage3.rs | 42 +++- .../src/protocols/jolt/emit/rust/stage4.rs | 42 +++- .../src/protocols/jolt/emit/rust/stage5.rs | 77 ++++-- .../src/protocols/jolt/emit/rust/stage6.rs | 74 ++++-- .../src/protocols/jolt/emit/rust/stage7.rs | 87 ++++++- .../src/protocols/jolt/rust_target_plan.rs | 231 +++++++++++++++++- .../bolt/src/protocols/jolt/verifier_plan.rs | 15 -- .../src/protocols/jolt/verifier_values.rs | 1 - crates/jolt-equivalence/src/plan_adapters.rs | 23 ++ crates/jolt-verifier/src/stages/stage3.rs | 6 +- crates/jolt-verifier/src/stages/stage4.rs | 4 +- crates/jolt-verifier/src/stages/stage5.rs | 7 +- crates/jolt-verifier/src/stages/stage6.rs | 3 +- crates/jolt-verifier/src/stages/stage7.rs | 8 +- 15 files changed, 693 insertions(+), 143 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 26c4f703e2..7ac9ef6466 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -262,6 +262,11 @@ pub struct FieldExprPlan { pub enum ValueExprKind { FieldVectorSum, FieldVectorProduct, + StructuredPolynomial { + polynomial: StructuredPolynomialKind, + x_point: StructuredPolynomialPointTransform, + y_point: StructuredPolynomialPointTransform, + }, PowerStridedWeightedSum { row_count: usize, power_stride: usize, @@ -385,6 +390,13 @@ pub struct StructuredPolynomialPointPlan { pub order: StructuredPolynomialPointOrder, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct StructuredPolynomialPointTransform { + pub segment: StructuredPolynomialPointSegment, + pub length: StructuredPolynomialPointLength, + pub order: StructuredPolynomialPointOrder, +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum StructuredPolynomialKind { Eq, @@ -1146,6 +1158,7 @@ impl ValueStore { }; self.try_field_vector(symbol).map(|values| values.to_vec()) } + ValueExprKind::StructuredPolynomial { .. } => None, ValueExprKind::PowerStridedWeightedSum { .. } => expr .operands .iter() @@ -1324,7 +1337,6 @@ pub fn eval_family_values( pub fn evaluate_relation_output( plan: &RelationOutputPlan, - relation_output_values: &[StructuredPolynomialEvalPlan], field_exprs: &[FieldExprPlan], value_exprs: &[ValueExprPlan], store: &ValueStore, @@ -1346,46 +1358,12 @@ pub fn evaluate_relation_output( for eval in evals { scratch.insert(eval.name, eval.value); } - for polynomial_eval_ref in plan.structured_polynomial_evals { - let polynomial_eval = relation_output_values - .get(polynomial_eval_ref.index) - .ok_or(RuntimePlanError::InvalidInputLength { - input: polynomial_eval_ref.symbol, - expected: polynomial_eval_ref.index + 1, - actual: relation_output_values.len(), - })?; - if polynomial_eval.symbol != polynomial_eval_ref.symbol { - return Err(RuntimePlanError::InvalidProof { - driver: instance_symbol, - reason: "relation output value reference mismatch", - }); - } - let x_raw_point = relation_output_x_point_source( - polynomial_eval.x_point.source, - instance_symbol, - local_points, - local_point, - store, - )?; - let y_raw_point = store.point_or(polynomial_eval.y_point.source, |symbol| { - RuntimePlanError::MissingValue { symbol } - })?; - let x_point = evaluate_structured_polynomial_point( - polynomial_eval.x_point, - x_raw_point, - x_raw_point, - y_raw_point, - )?; - let y_point = evaluate_structured_polynomial_point( - polynomial_eval.y_point, - y_raw_point, - x_raw_point, - y_raw_point, - )?; - let value = evaluate_structured_polynomial(polynomial_eval.polynomial, &x_point, y_point)?; - scratch.insert(polynomial_eval.symbol, value); - } - evaluate_available_exprs_with_scratch(field_exprs, value_exprs, store, &mut scratch)?; + let context = RelationOutputContext { + instance_symbol, + local_points, + local_point, + }; + evaluate_available_exprs_with_scratch(field_exprs, value_exprs, store, &mut scratch, context)?; scratch .scalar_or(store, plan.expected_output) .ok_or(RuntimePlanError::MissingValue { @@ -1395,7 +1373,6 @@ pub fn evaluate_relation_output( pub fn evaluate_relation_output_for_instance( relation_outputs: &[RelationOutputPlan], - relation_output_values: &[StructuredPolynomialEvalPlan], field_exprs: &[FieldExprPlan], value_exprs: &[ValueExprPlan], store: &ValueStore, @@ -1414,7 +1391,6 @@ pub fn evaluate_relation_output_for_instance( })?; evaluate_relation_output( relation_output, - relation_output_values, field_exprs, value_exprs, store, @@ -1442,6 +1418,13 @@ fn relation_output_x_point_source<'a>( .ok_or(RuntimePlanError::MissingValue { symbol: source }) } +#[derive(Clone, Copy)] +struct RelationOutputContext<'a> { + instance_symbol: &'static str, + local_points: &'a [NamedPoint<'a, Fr>], + local_point: &'a [Fr], +} + fn evaluate_structured_polynomial_point( plan: StructuredPolynomialPointPlan, raw_point: &[Fr], @@ -1529,6 +1512,7 @@ fn evaluate_available_exprs_with_scratch( value_exprs: &[ValueExprPlan], store: &ValueStore, scratch: &mut ScratchScalars, + context: RelationOutputContext<'_>, ) -> Result<(), RuntimePlanError> { loop { let mut progress = 0usize; @@ -1546,10 +1530,11 @@ fn evaluate_available_exprs_with_scratch( if scratch.scalar_or(store, expr.symbol).is_some() { continue; } - let Some(operands) = relation_output_value_expr_operands(expr, store, scratch) else { + let Some(value) = evaluate_relation_output_value_expr(expr, store, scratch, context)? + else { continue; }; - scratch.insert(expr.symbol, evaluate_value_expr(expr, &operands)?); + scratch.insert(expr.symbol, value); progress += 1; } if progress == 0 { @@ -1569,26 +1554,87 @@ fn relation_output_expr_operands( .collect() } -fn relation_output_value_expr_operands( +fn evaluate_relation_output_value_expr( expr: &ValueExprPlan, store: &ValueStore, scratch: &ScratchScalars, -) -> Option> { + context: RelationOutputContext<'_>, +) -> Result, RuntimePlanError> { match expr.kind { ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { let [symbol] = expr.operands else { - return Some(Vec::new()); + return evaluate_value_expr(expr, &[]).map(Some); }; - store.try_field_vector(symbol).map(|values| values.to_vec()) + let Some(values) = store.try_field_vector(symbol) else { + return Ok(None); + }; + evaluate_value_expr(expr, values).map(Some) } + ValueExprKind::StructuredPolynomial { + polynomial, + x_point, + y_point, + } => evaluate_structured_polynomial_value( + expr.symbol, + expr.operands, + polynomial, + x_point, + y_point, + store, + context, + ) + .map(Some), ValueExprKind::PowerStridedWeightedSum { .. } => expr .operands .iter() .map(|operand| scratch.scalar_or(store, operand)) - .collect(), + .collect::>>() + .map(|operands| evaluate_value_expr(expr, &operands).map(Some)) + .transpose() + .map(Option::flatten), } } +fn evaluate_structured_polynomial_value( + symbol: &'static str, + operands: &[&'static str], + polynomial: StructuredPolynomialKind, + x_transform: StructuredPolynomialPointTransform, + y_transform: StructuredPolynomialPointTransform, + store: &ValueStore, + context: RelationOutputContext<'_>, +) -> Result { + require_operand_count(symbol, 2, operands.len())?; + let x_source = operands[0]; + let y_source = operands[1]; + let x_raw_point = relation_output_x_point_source( + x_source, + context.instance_symbol, + context.local_points, + context.local_point, + store, + )?; + let y_raw_point = + store.point_or(y_source, |symbol| RuntimePlanError::MissingValue { symbol })?; + let x_plan = StructuredPolynomialPointPlan { + source: x_source, + segment: x_transform.segment, + length: x_transform.length, + order: x_transform.order, + }; + let y_plan = StructuredPolynomialPointPlan { + source: y_source, + segment: y_transform.segment, + length: y_transform.length, + order: y_transform.order, + }; + let x_point = + evaluate_structured_polynomial_point(x_plan, x_raw_point, x_raw_point, y_raw_point)?; + let y_point = + evaluate_structured_polynomial_point(y_plan, y_raw_point, x_raw_point, y_raw_point)?; + evaluate_structured_polynomial(polynomial, &x_point, y_point) +} + pub fn single_operand( symbol: &'static str, operands: &[F], @@ -1703,6 +1749,10 @@ pub fn evaluate_value_expr( .copied() .fold(F::from_u64(1), |acc, operand| acc * operand)) } + ValueExprKind::StructuredPolynomial { .. } => Err(RuntimePlanError::InvalidProof { + driver: expr.symbol, + reason: "structured polynomial value expressions require relation-output point context", + }), ValueExprKind::PowerStridedWeightedSum { row_count, power_stride, @@ -1914,10 +1964,18 @@ pub fn reverse_slice(values: &[Fr]) -> Vec { )] mod tests { use super::{ - evaluate_value_expr, Fr, NamedEvalFamilyPlan, RuntimePlanError, ValueExprKind, - ValueExprPlan, ValueStore, + evaluate_relation_output_for_instance, evaluate_value_expr, Fr, NamedEvalFamilyPlan, + RelationOutputPlan, RuntimePlanError, StructuredPolynomialKind, + StructuredPolynomialPointLength, StructuredPolynomialPointOrder, + StructuredPolynomialPointSegment, StructuredPolynomialPointTransform, + SumcheckInstanceResultPlan, SumcheckPointOrder, ValueExprKind, ValueExprPlan, ValueStore, }; + #[derive(Clone, Copy, Debug, PartialEq, Eq)] + enum TestRelation { + Output, + } + #[test] fn value_store_evaluates_named_eval_families_as_field_vectors() { let mut store = ValueStore::default(); @@ -2009,4 +2067,58 @@ mod tests { assert_eq!(value, Fr::from_u64(2857)); } + + #[test] + fn relation_output_evaluates_structured_polynomial_value_exprs() { + let x = [Fr::from_u64(1), Fr::from_u64(0)]; + let mut store = ValueStore::default(); + store.insert_point("point.y", x.to_vec()); + + let value = evaluate_relation_output_for_instance( + &[RelationOutputPlan { + relation: TestRelation::Output, + structured_polynomial_evals: &[], + local_scalars: &[], + expected_output: "eq.xy", + }], + &[], + &[ValueExprPlan { + symbol: "eq.xy", + kind: ValueExprKind::StructuredPolynomial { + polynomial: StructuredPolynomialKind::Eq, + x_point: StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + y_point: StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + }, + operands: &["instance", "point.y"], + }], + &store, + &SumcheckInstanceResultPlan { + symbol: "instance", + source: "driver", + claim: "claim", + relation: TestRelation::Output, + index: 0, + point_arity: 2, + num_rounds: 2, + round_offset: 0, + point_order: SumcheckPointOrder::AsIs, + degree: 2, + }, + &[], + &[], + &[], + &x, + ) + .unwrap(); + + assert_eq!(value, Fr::from_u64(1)); + } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 29e325cf54..85ae9a3ae7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -6,6 +6,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::rust_target_plan::structured_polynomial_value_formula; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, FieldExprDependencies, RelationOutputAst as Stage3RelationOutputAst, @@ -118,6 +119,27 @@ impl FieldExprDependencies for Stage3FieldExprPlan { } } +fn stage3_structured_polynomial_value_expr( + value: &Stage3StructuredPolynomialEvalPlan, +) -> Stage3ValueExprPlan { + let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; + Stage3ValueExprPlan { + symbol: value.symbol.clone(), + kind: "op".to_owned(), + formula: structured_polynomial_value_formula( + value.polynomial.as_str(), + value.x_point.segment.as_str(), + value.x_point.length.as_str(), + value.x_point.order.as_str(), + value.y_point.segment.as_str(), + value.y_point.length.as_str(), + value.y_point.order.as_str(), + ), + operand_names: operands.clone(), + operands, + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage3SumcheckClaimPlan { pub symbol: String, @@ -276,7 +298,7 @@ impl Stage3CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); - let value_exprs = Vec::new(); + let mut value_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -583,6 +605,13 @@ impl Stage3CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; + if is_verifier { + value_exprs.extend( + relation_output_values + .iter() + .map(stage3_structured_polynomial_value_expr), + ); + } if role == Role::Prover { verifier_relation_outputs::prune_output_only_field_exprs( &mut field_exprs, @@ -745,14 +774,12 @@ impl Stage3CpuProgram { verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.evals.iter().map(|eval| &eval.symbol), - verifier_values::VerifierScalarSourceKind::SumcheckEval, + self.value_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ValueExpr, ); values.extend( - self.relation_output_values - .iter() - .map(|value| &value.symbol), - verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, + self.evals.iter().map(|eval| &eval.symbol), + verifier_values::VerifierScalarSourceKind::SumcheckEval, ); values } @@ -2203,7 +2230,6 @@ fn expected_batched_output_claim( })?; let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 3ad45ddf93..a7c24d9a85 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -11,6 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::rust_target_plan::structured_polynomial_value_formula; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, FieldExprDependencies, RelationOutputAst as Stage4RelationOutputAst, @@ -131,6 +132,27 @@ impl FieldExprDependencies for Stage4FieldExprPlan { } } +fn stage4_structured_polynomial_value_expr( + value: &Stage4StructuredPolynomialEvalPlan, +) -> Stage4ValueExprPlan { + let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; + Stage4ValueExprPlan { + symbol: value.symbol.clone(), + kind: "op".to_owned(), + formula: structured_polynomial_value_formula( + value.polynomial.as_str(), + value.x_point.segment.as_str(), + value.x_point.length.as_str(), + value.x_point.order.as_str(), + value.y_point.segment.as_str(), + value.y_point.length.as_str(), + value.y_point.order.as_str(), + ), + operand_names: operands.clone(), + operands, + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage4SumcheckClaimPlan { pub symbol: String, @@ -291,7 +313,7 @@ impl Stage4CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); - let value_exprs = Vec::new(); + let mut value_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -595,6 +617,13 @@ impl Stage4CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; + if is_verifier { + value_exprs.extend( + relation_output_values + .iter() + .map(stage4_structured_polynomial_value_expr), + ); + } if role == Role::Prover { verifier_relation_outputs::prune_output_only_field_exprs( &mut field_exprs, @@ -761,16 +790,14 @@ impl Stage4CpuProgram { .map(|squeeze| &squeeze.symbol), verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); - values.extend( - self.relation_output_values - .iter() - .map(|value| &value.symbol), - verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, - ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), verifier_values::VerifierScalarSourceKind::FieldExpr, ); + values.extend( + self.value_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ValueExpr, + ); values.extend( self.evals.iter().map(|eval| &eval.symbol), verifier_values::VerifierScalarSourceKind::SumcheckEval, @@ -2449,7 +2476,6 @@ fn expected_batched_output_claim( })?; let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 37f7a25ed4..483ffe1d29 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -11,7 +11,9 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ValueExprKind}; +use crate::protocols::jolt::rust_target_plan::{ + structured_polynomial_value_formula, FieldExprKind, ValueExprKind, +}; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, }; @@ -232,6 +234,27 @@ fn stage5_value_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage } } +fn stage5_structured_polynomial_value_expr( + value: &Stage5StructuredPolynomialEvalPlan, +) -> Stage5ValueExprPlan { + let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; + Stage5ValueExprPlan { + symbol: value.symbol.clone(), + kind: "op".to_owned(), + formula: structured_polynomial_value_formula( + value.polynomial.as_str(), + value.x_point.segment.as_str(), + value.x_point.length.as_str(), + value.x_point.order.as_str(), + value.y_point.segment.as_str(), + value.y_point.length.as_str(), + value.y_point.order.as_str(), + ), + operand_names: operands.clone(), + operands, + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage5PointSlicePlan { pub symbol: String, @@ -693,6 +716,13 @@ impl Stage5CpuProgram { } relation_outputs.push(output_claim); } + if role == Role::Verifier { + value_exprs.extend( + relation_output_values + .iter() + .map(stage5_structured_polynomial_value_expr), + ); + } let mut program = Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, @@ -802,6 +832,11 @@ impl Stage5CpuProgram { } else { None }; + let point_values = if self.role == Role::Verifier { + Some(self.verifier_plan()?.point_value_sources()) + } else { + None + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -858,6 +893,25 @@ impl Stage5CpuProgram { } } } + ValueExprKind::StructuredPolynomial { .. } => { + verify_count( + "structured polynomial value expr operands", + &expr.symbol, + 2, + expr.operands.len(), + )?; + for operand in &expr.operands { + if !point_values + .as_ref() + .is_some_and(|values| values.contains(operand)) + { + return Err(EmitError::new(format!( + "structured polynomial value expr @{} references missing point value @{operand}", + expr.symbol + ))); + } + } + } } } for claim in &self.claims { @@ -888,21 +942,6 @@ impl Stage5CpuProgram { .map(|squeeze| &squeeze.symbol), verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); - values.extend( - self.relation_output_values - .iter() - .map(|value| &value.symbol), - verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, - ); - values.extend( - self.relation_outputs.iter().flat_map(|claim| { - claim - .structured_polynomial_evals - .iter() - .map(|value| &value.symbol) - }), - verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, - ); values.extend( self.relation_output_eval_families .iter() @@ -937,6 +976,10 @@ impl Stage5CpuProgram { self.field_exprs.iter().map(|expr| &expr.symbol), verifier_values::VerifierScalarSourceKind::FieldExpr, ); + values.extend( + self.value_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ValueExpr, + ); values.extend( self.relation_outputs .iter() @@ -2615,7 +2658,6 @@ fn expected_batched_output_claim( )?; bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, @@ -2630,7 +2672,6 @@ fn expected_batched_output_claim( | Stage5RelationKind::Stage5RegistersValEvaluation => { bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 339cb158c6..df6eca79b5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -11,7 +11,9 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ValueExprKind}; +use crate::protocols::jolt::rust_target_plan::{ + structured_polynomial_value_formula, FieldExprKind, ValueExprKind, +}; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, stage6_bytecode_read_raf_relation_output_plan, STAGE6_BYTECODE_RA_EVAL_FAMILY, @@ -724,6 +726,11 @@ impl Stage6CpuProgram { } } relation_outputs.push(bytecode_output_plan.claim); + value_exprs.extend( + relation_output_values + .iter() + .map(stage6_structured_polynomial_value_expr), + ); } let mut program = Self { @@ -835,6 +842,11 @@ impl Stage6CpuProgram { } else { None }; + let point_values = if self.role == Role::Verifier { + Some(self.verifier_plan()?.point_value_sources()) + } else { + None + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -891,6 +903,25 @@ impl Stage6CpuProgram { } } } + ValueExprKind::StructuredPolynomial { .. } => { + verify_count( + "structured polynomial value expr operands", + &expr.symbol, + 2, + expr.operands.len(), + )?; + for operand in &expr.operands { + if !point_values + .as_ref() + .is_some_and(|values| values.contains(operand)) + { + return Err(EmitError::new(format!( + "structured polynomial value expr @{} references missing point value @{operand}", + expr.symbol + ))); + } + } + } } } for claim in &self.claims { @@ -921,21 +952,6 @@ impl Stage6CpuProgram { .map(|squeeze| &squeeze.symbol), verifier_values::VerifierScalarSourceKind::TranscriptScalar, ); - values.extend( - self.relation_output_values - .iter() - .map(|value| &value.symbol), - verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, - ); - values.extend( - self.relation_outputs.iter().flat_map(|claim| { - claim - .structured_polynomial_evals - .iter() - .map(|value| &value.symbol) - }), - verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, - ); values.extend( self.relation_output_eval_families .iter() @@ -970,6 +986,10 @@ impl Stage6CpuProgram { self.field_exprs.iter().map(|expr| &expr.symbol), verifier_values::VerifierScalarSourceKind::FieldExpr, ); + values.extend( + self.value_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ValueExpr, + ); values.extend( self.relation_outputs .iter() @@ -2814,7 +2834,6 @@ fn expected_plan_relation_output( ) -> Result { Ok(bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, @@ -2932,6 +2951,27 @@ fn stage6_value_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage6ValueExpr } } +fn stage6_structured_polynomial_value_expr( + value: &Stage6StructuredPolynomialEvalPlan, +) -> Stage6ValueExprPlan { + let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; + Stage6ValueExprPlan { + symbol: value.symbol.clone(), + kind: "op".to_owned(), + formula: structured_polynomial_value_formula( + value.polynomial.as_str(), + value.x_point.segment.as_str(), + value.x_point.length.as_str(), + value.x_point.order.as_str(), + value.y_point.segment.as_str(), + value.y_point.length.as_str(), + value.y_point.order.as_str(), + ), + operand_names: operands.clone(), + operands, + } +} + fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { STAGE6_KERNEL_ABIS .iter() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index a13b0012ae..ac5be47c41 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -11,7 +11,9 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::{power_strided_weighted_sum_formula, ValueExprKind}; +use crate::protocols::jolt::rust_target_plan::{ + power_strided_weighted_sum_formula, structured_polynomial_value_formula, ValueExprKind, +}; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, @@ -175,6 +177,27 @@ fn stage7_value_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage7ValueExpr } } +fn stage7_structured_polynomial_value_expr( + value: &Stage7StructuredPolynomialEvalPlan, +) -> Stage7ValueExprPlan { + let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; + Stage7ValueExprPlan { + symbol: value.symbol.clone(), + kind: "op".to_owned(), + formula: structured_polynomial_value_formula( + value.polynomial.as_str(), + value.x_point.segment.as_str(), + value.x_point.length.as_str(), + value.x_point.order.as_str(), + value.y_point.segment.as_str(), + value.y_point.length.as_str(), + value.y_point.order.as_str(), + ), + operand_names: operands.clone(), + operands, + } +} + struct HammingWeightClaimRow { hamming_factor: String, booleanity: String, @@ -843,6 +866,13 @@ impl Stage7CpuProgram { } else { Vec::new() }; + if role == Role::Verifier { + value_exprs.extend( + relation_output_values + .iter() + .map(stage7_structured_polynomial_value_expr), + ); + } let mut program = Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, @@ -947,6 +977,11 @@ impl Stage7CpuProgram { } else { self.cpu_field_value_sources() }; + let point_values = if self.role == Role::Verifier { + Some(self.verifier_plan()?.point_value_sources()) + } else { + None + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -970,13 +1005,42 @@ impl Stage7CpuProgram { expr.operand_names.len(), expr.operands.len(), )?; - let _kind = ValueExprKind::from_cpu_attr(&expr.formula) + let kind = ValueExprKind::from_cpu_attr(&expr.formula) .map_err(|error| EmitError::new(error.to_string()))?; - for operand in &expr.operands { - if !field_values.contains(operand) { + match kind { + ValueExprKind::PowerStridedWeightedSum { .. } => { + for operand in &expr.operands { + if !field_values.contains(operand) { + return Err(EmitError::new(format!( + "value expr @{} references missing field value @{operand}", + expr.symbol + ))); + } + } + } + ValueExprKind::StructuredPolynomial { .. } => { + verify_count( + "structured polynomial value expr operands", + &expr.symbol, + 2, + expr.operands.len(), + )?; + for operand in &expr.operands { + if !point_values + .as_ref() + .is_some_and(|values| values.contains(operand)) + { + return Err(EmitError::new(format!( + "structured polynomial value expr @{} references missing point value @{operand}", + expr.symbol + ))); + } + } + } + ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { return Err(EmitError::new(format!( - "value expr @{} references missing field value @{operand}", - expr.symbol + "stage7 value expr @{} uses unsupported field-vector formula `{}`", + expr.symbol, expr.formula ))); } } @@ -1014,14 +1078,12 @@ impl Stage7CpuProgram { verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.evals.iter().map(|eval| &eval.symbol), - verifier_values::VerifierScalarSourceKind::SumcheckEval, + self.value_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ValueExpr, ); values.extend( - self.relation_output_values - .iter() - .map(|value| &value.symbol), - verifier_values::VerifierScalarSourceKind::StructuredPolynomialEval, + self.evals.iter().map(|eval| &eval.symbol), + verifier_values::VerifierScalarSourceKind::SumcheckEval, ); values.extend( self.relation_output_eval_families @@ -2736,7 +2798,6 @@ fn expected_batched_output_claim( Stage7RelationKind::Stage7HammingWeightClaimReduction => { bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index 0c14c65aad..9517ee3017 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -269,6 +269,11 @@ pub(crate) enum FieldExprKind { pub(crate) enum ValueExprKind { FieldVectorSum, FieldVectorProduct, + StructuredPolynomial { + polynomial: StructuredPolynomialKind, + x_point: StructuredPolynomialPointTransform, + y_point: StructuredPolynomialPointTransform, + }, PowerStridedWeightedSum { row_count: usize, power_stride: usize, @@ -278,6 +283,40 @@ pub(crate) enum ValueExprKind { }, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum StructuredPolynomialKind { + Eq, + EqPlusOne, + Lt, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum StructuredPolynomialPointSegment { + Full, + Prefix, + Suffix, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum StructuredPolynomialPointLength { + Full, + XPoint, + YPoint, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum StructuredPolynomialPointOrder { + AsIs, + Reverse, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment, + length: StructuredPolynomialPointLength, + order: StructuredPolynomialPointOrder, +} + impl FieldExprKind { pub(crate) fn from_cpu_attr(value: &str) -> Result { match value { @@ -321,6 +360,9 @@ impl ValueExprKind { match value { "field_vector.sum" => Ok(Self::FieldVectorSum), "field_vector.product" => Ok(Self::FieldVectorProduct), + value if value.starts_with("poly.structured_eval:") => { + parse_structured_polynomial_value(value) + } value if value.starts_with("field.power_strided_weighted_sum:") => { parse_power_strided_weighted_sum(value) } @@ -335,6 +377,16 @@ impl ValueExprKind { match self { Self::FieldVectorSum => "FieldVectorSum".to_owned(), Self::FieldVectorProduct => "FieldVectorProduct".to_owned(), + Self::StructuredPolynomial { + polynomial, + x_point, + y_point, + } => format!( + "StructuredPolynomial {{ polynomial: {}, x_point: {}, y_point: {} }}", + polynomial.rust_variant_expr(), + x_point.rust_expr(), + y_point.rust_expr(), + ), Self::PowerStridedWeightedSum { row_count, power_stride, @@ -351,6 +403,111 @@ impl ValueExprKind { } } +impl StructuredPolynomialKind { + fn from_attr(value: &str) -> Result { + match value { + "eq" => Ok(Self::Eq), + "eq_plus_one" => Ok(Self::EqPlusOne), + "lt" => Ok(Self::Lt), + _ => Err(RustTargetPlanError::unsupported( + "structured polynomial kind", + value, + )), + } + } + + fn rust_variant_expr(&self) -> &'static str { + match self { + Self::Eq => "bolt_verifier_runtime::StructuredPolynomialKind::Eq", + Self::EqPlusOne => "bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne", + Self::Lt => "bolt_verifier_runtime::StructuredPolynomialKind::Lt", + } + } +} + +impl StructuredPolynomialPointSegment { + fn from_attr(value: &str) -> Result { + match value { + "full" => Ok(Self::Full), + "prefix" => Ok(Self::Prefix), + "suffix" => Ok(Self::Suffix), + _ => Err(RustTargetPlanError::unsupported( + "structured polynomial point segment", + value, + )), + } + } + + fn rust_variant_expr(&self) -> &'static str { + match self { + Self::Full => "bolt_verifier_runtime::StructuredPolynomialPointSegment::Full", + Self::Prefix => "bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix", + Self::Suffix => "bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix", + } + } +} + +impl StructuredPolynomialPointLength { + fn from_attr(value: &str) -> Result { + match value { + "full" => Ok(Self::Full), + "x_point" => Ok(Self::XPoint), + "y_point" => Ok(Self::YPoint), + _ => Err(RustTargetPlanError::unsupported( + "structured polynomial point length", + value, + )), + } + } + + fn rust_variant_expr(&self) -> &'static str { + match self { + Self::Full => "bolt_verifier_runtime::StructuredPolynomialPointLength::Full", + Self::XPoint => "bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint", + Self::YPoint => "bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint", + } + } +} + +impl StructuredPolynomialPointOrder { + fn from_attr(value: &str) -> Result { + match value { + "as_is" => Ok(Self::AsIs), + "reverse" => Ok(Self::Reverse), + _ => Err(RustTargetPlanError::unsupported( + "structured polynomial point order", + value, + )), + } + } + + fn rust_variant_expr(&self) -> &'static str { + match self { + Self::AsIs => "bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs", + Self::Reverse => "bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse", + } + } +} + +impl StructuredPolynomialPointTransform { + fn new(segment: &str, length: &str, order: &str) -> Result { + Ok(Self { + segment: StructuredPolynomialPointSegment::from_attr(segment)?, + length: StructuredPolynomialPointLength::from_attr(length)?, + order: StructuredPolynomialPointOrder::from_attr(order)?, + }) + } + + fn rust_expr(&self) -> String { + format!( + "bolt_verifier_runtime::StructuredPolynomialPointTransform {{ segment: {}, length: {}, order: {} }}", + self.segment.rust_variant_expr(), + self.length.rust_variant_expr(), + self.order.rust_variant_expr(), + ) + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum PcsProofMode { Open, @@ -459,6 +616,25 @@ fn parse_power_strided_weighted_sum(value: &str) -> Result Result { + let spec = value + .strip_prefix("poly.structured_eval:") + .ok_or_else(|| RustTargetPlanError::unsupported("value expression formula", value))?; + let [polynomial, x_segment, x_length, x_order, y_segment, y_length, y_order] = + spec.split(':').collect::>()[..] + else { + return Err(RustTargetPlanError::unsupported( + "value expression formula", + value, + )); + }; + Ok(ValueExprKind::StructuredPolynomial { + polynomial: StructuredPolynomialKind::from_attr(polynomial)?, + x_point: StructuredPolynomialPointTransform::new(x_segment, x_length, x_order)?, + y_point: StructuredPolynomialPointTransform::new(y_segment, y_length, y_order)?, + }) +} + pub(crate) fn power_strided_weighted_sum_formula( row_count: usize, power_stride: usize, @@ -474,6 +650,20 @@ pub(crate) fn power_strided_weighted_sum_formula( ) } +pub(crate) fn structured_polynomial_value_formula( + polynomial: &str, + x_segment: &str, + x_length: &str, + x_order: &str, + y_segment: &str, + y_length: &str, + y_order: &str, +) -> String { + format!( + "poly.structured_eval:{polynomial}:{x_segment}:{x_length}:{x_order}:{y_segment}:{y_length}:{y_order}" + ) +} + fn parse_usize_list(value: &str, full_formula: &str) -> Result, RustTargetPlanError> { if value == "_" { return Ok(Vec::new()); @@ -515,7 +705,9 @@ fn usize_slice_expr(values: &[usize]) -> String { mod tests { use super::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode, - ProgramStepKind, TranscriptSqueezeKind, ValueExprKind, + ProgramStepKind, StructuredPolynomialKind, StructuredPolynomialPointLength, + StructuredPolynomialPointOrder, StructuredPolynomialPointSegment, + StructuredPolynomialPointTransform, TranscriptSqueezeKind, ValueExprKind, }; #[test] @@ -593,7 +785,27 @@ mod tests { row_term_offsets: vec![2], }) ); + assert_eq!( + ValueExprKind::from_cpu_attr( + "poly.structured_eval:lt:suffix:y_point:reverse:full:full:as_is" + ) + .ok(), + Some(ValueExprKind::StructuredPolynomial { + polynomial: StructuredPolynomialKind::Lt, + x_point: StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment::Suffix, + length: StructuredPolynomialPointLength::YPoint, + order: StructuredPolynomialPointOrder::Reverse, + }, + y_point: StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + }) + ); assert!(ValueExprKind::from_cpu_attr("field.power_strided_weighted_sum:1:2:0").is_err()); + assert!(ValueExprKind::from_cpu_attr("poly.structured_eval:eq:full").is_err()); } #[test] @@ -622,5 +834,22 @@ mod tests { .rust_variant_expr(), "PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }" ); + assert_eq!( + ValueExprKind::StructuredPolynomial { + polynomial: StructuredPolynomialKind::EqPlusOne, + x_point: StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment::Prefix, + length: StructuredPolynomialPointLength::YPoint, + order: StructuredPolynomialPointOrder::Reverse, + }, + y_point: StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + } + .rust_variant_expr(), + "StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }" + ); } } diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 4901a94567..0ad3a01766 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -322,21 +322,6 @@ impl VerifierStagePlan { .map(|squeeze| &squeeze.symbol), VerifierScalarSourceKind::TranscriptScalar, ); - values.extend( - self.relation_output_values - .iter() - .map(|value| &value.symbol), - VerifierScalarSourceKind::StructuredPolynomialEval, - ); - values.extend( - self.relation_outputs.iter().flat_map(|claim| { - claim - .structured_polynomial_evals - .iter() - .map(|value| &value.symbol) - }), - VerifierScalarSourceKind::StructuredPolynomialEval, - ); values.extend( self.relation_output_eval_families .iter() diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index ad564d34ef..865dc52b75 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -11,7 +11,6 @@ pub enum VerifierScalarSourceKind { ValueExpr, PointDerived, SumcheckEval, - StructuredPolynomialEval, OutputEvalFamily, OutputProductFamily, OutputFunctionFamily, diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index a6e4a503c3..f7fbbb46c0 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -339,6 +339,29 @@ fn generated_value_expr_kind(value: &str) -> bolt_verifier_runtime::ValueExprKin row_term_offsets: leak_slice(parse_usize_list(parts[4])), } } + value if value.starts_with("poly.structured_eval:") => { + let spec = value + .strip_prefix("poly.structured_eval:") + .expect("structured polynomial expression has prefix"); + let parts = spec.split(':').collect::>(); + assert!( + parts.len() == 7, + "structured polynomial expression has seven fields" + ); + bolt_verifier_runtime::ValueExprKind::StructuredPolynomial { + polynomial: generated_structured_polynomial_kind(parts[0]), + x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { + segment: generated_structured_polynomial_point_segment(parts[1]), + length: generated_structured_polynomial_point_length(parts[2]), + order: generated_structured_polynomial_point_order(parts[3]), + }, + y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { + segment: generated_structured_polynomial_point_segment(parts[4]), + length: generated_structured_polynomial_point_length(parts[5]), + order: generated_structured_polynomial_point_order(parts[6]), + }, + } + } value => panic!("unsupported generated value expression kind `{value}`"), } } diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index d15be64412..fcf40b9362 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -139,7 +139,10 @@ pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[ Stage3FieldExprPlan { symbol: "stage3.registers.output.claim_expr", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.output.eq.RdWriteValue", "stage3.registers.output.weighted_register_values"] }, ]; pub const STAGE3_VALUE_EXPRS: &[Stage3ValueExprPlan] = &[ - + Stage3ValueExprPlan { symbol: "stage3.spartan_shift.output.eq.NextPC", kind: Stage3ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.spartan_shift.instance", "stage3.input.stage1.NextPC"] }, + Stage3ValueExprPlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", kind: Stage3ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.spartan_shift.instance", "stage3.input.stage2.product_virtual.NextIsNoop"] }, + Stage3ValueExprPlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", kind: Stage3ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.instruction_input.instance", "stage3.input.stage2.product_virtual.LeftInstructionInput"] }, + Stage3ValueExprPlan { symbol: "stage3.registers.output.eq.RdWriteValue", kind: Stage3ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.registers_claim_reduction.instance", "stage3.input.stage1.RdWriteValue"] }, ]; pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[ Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr" }, @@ -491,7 +494,6 @@ fn expected_batched_output_claim( })?; let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index a7ca92d8d0..45d42c1ff3 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -118,7 +118,8 @@ pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[ Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.claim_expr", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.output.term.RamIncRamRa", "stage4.ram_val_check.output.lt_plus_gamma"] }, ]; pub const STAGE4_VALUE_EXPRS: &[Stage4ValueExprPlan] = &[ - + Stage4ValueExprPlan { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", kind: Stage4ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage4.registers_read_write.instance", "stage4.input.stage3.registers.RdWriteValue"] }, + Stage4ValueExprPlan { symbol: "stage4.ram_val_check.output.lt.RamValCycle", kind: Stage4ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Lt, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage4.ram_val_check.instance", "stage4.input.stage2.RamVal"] }, ]; pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[ @@ -471,7 +472,6 @@ fn expected_batched_output_claim( })?; let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 3e009e9c2a..c25b7b9b9d 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -168,6 +168,11 @@ pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[ ]; pub const STAGE5_VALUE_EXPRS: &[Stage5ValueExprPlan] = &[ Stage5ValueExprPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", kind: Stage5ValueExprKind::FieldVectorProduct, operands: &["stage5.instruction_read_raf.eval.InstructionRa"] }, + Stage5ValueExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", kind: Stage5ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage2.ram_raf.RamRa"] }, + Stage5ValueExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", kind: Stage5ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage2.ram_read_write.RamRa"] }, + Stage5ValueExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", kind: Stage5ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage4.ram_val_check.RamRa"] }, + Stage5ValueExprPlan { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", kind: Stage5ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Lt, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.registers_val_evaluation.instance", "stage5.input.stage4.registers.RegistersVal"] }, + Stage5ValueExprPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", kind: Stage5ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.instruction_read_raf.instance", "stage5.input.stage2.instruction.LookupOutput"] }, ]; pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[ @@ -716,7 +721,6 @@ fn expected_batched_output_claim( )?; bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, @@ -731,7 +735,6 @@ fn expected_batched_output_claim( | Stage5RelationKind::Stage5RegistersValEvaluation => { bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 16b8116f22..8cf4c2a285 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -327,7 +327,7 @@ const fn stage6_value_expr(symbol: &'static str, kind: Stage6ValueExprKind, oper #[rustfmt::skip] pub const STAGE6_VALUE_EXPRS: &[Stage6ValueExprPlan] = &[ - stage6_value_expr("stage6.bytecode_read_raf.output.product.BytecodeRa", Stage6ValueExprKind::FieldVectorProduct, &["stage6.bytecode_read_raf.eval.BytecodeRa"]), + stage6_value_expr("stage6.bytecode_read_raf.output.product.BytecodeRa", Stage6ValueExprKind::FieldVectorProduct, &["stage6.bytecode_read_raf.eval.BytecodeRa"]), stage6_value_expr("stage6.booleanity.output.eq.InstructionRa0", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.booleanity.instance", "stage6.booleanity.output.point"]), stage6_value_expr("stage6.hamming_booleanity.output.eq.LookupOutput", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse } }, &["stage6.hamming_booleanity.instance", "stage6.input.stage1.LookupOutput"]), stage6_value_expr("stage6.ram_ra_virtual.output.eq.Cycle", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.ram_ra_virtual.instance", "stage6.input.stage5.ram_ra_claim_reduction.RamRa"]), stage6_value_expr("stage6.instruction_ra_virtual.output.eq.Cycle", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.instruction_ra_virtual.instance", "stage6.input.stage5.instruction_read_raf.InstructionRa_0"]), stage6_value_expr("stage6.inc_claim_reduction.output.eq.RamIncStage2", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage2.ram_read_write.RamInc"]), stage6_value_expr("stage6.inc_claim_reduction.output.eq.RamIncStage4", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_value_expr("stage6.inc_claim_reduction.output.eq.RdIncStage4", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_value_expr("stage6.inc_claim_reduction.output.eq.RdIncStage5", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage5.registers_val_evaluation.RdInc"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -1048,7 +1048,6 @@ fn expected_plan_relation_output( ) -> Result { Ok(bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 955af5b4bf..f5fe1fbe16 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -177,7 +177,12 @@ const fn stage7_value_expr(symbol: &'static str, kind: Stage7ValueExprKind, oper #[rustfmt::skip] pub const STAGE7_VALUE_EXPRS: &[Stage7ValueExprPlan] = &[ - stage7_value_expr("stage7.hamming_weight_claim_reduction.input.claim_expr", Stage7ValueExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[], shared_term_offsets: &[], row_term_offsets: &[0, 1, 2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.booleanity.InstructionRa_0", "stage7.input.stage6.booleanity.InstructionRa_1", "stage7.input.stage6.booleanity.InstructionRa_2", "stage7.input.stage6.booleanity.InstructionRa_3", "stage7.input.stage6.booleanity.InstructionRa_4", "stage7.input.stage6.booleanity.InstructionRa_5", "stage7.input.stage6.booleanity.InstructionRa_6", "stage7.input.stage6.booleanity.InstructionRa_7", "stage7.input.stage6.booleanity.InstructionRa_8", "stage7.input.stage6.booleanity.InstructionRa_9", "stage7.input.stage6.booleanity.InstructionRa_10", "stage7.input.stage6.booleanity.InstructionRa_11", "stage7.input.stage6.booleanity.InstructionRa_12", "stage7.input.stage6.booleanity.InstructionRa_13", "stage7.input.stage6.booleanity.InstructionRa_14", "stage7.input.stage6.booleanity.InstructionRa_15", "stage7.input.stage6.booleanity.InstructionRa_16", "stage7.input.stage6.booleanity.InstructionRa_17", "stage7.input.stage6.booleanity.InstructionRa_18", "stage7.input.stage6.booleanity.InstructionRa_19", "stage7.input.stage6.booleanity.InstructionRa_20", "stage7.input.stage6.booleanity.InstructionRa_21", "stage7.input.stage6.booleanity.InstructionRa_22", "stage7.input.stage6.booleanity.InstructionRa_23", "stage7.input.stage6.booleanity.InstructionRa_24", "stage7.input.stage6.booleanity.InstructionRa_25", "stage7.input.stage6.booleanity.InstructionRa_26", "stage7.input.stage6.booleanity.InstructionRa_27", "stage7.input.stage6.booleanity.InstructionRa_28", "stage7.input.stage6.booleanity.InstructionRa_29", "stage7.input.stage6.booleanity.InstructionRa_30", "stage7.input.stage6.booleanity.InstructionRa_31", "stage7.input.stage6.booleanity.BytecodeRa_0", "stage7.input.stage6.booleanity.BytecodeRa_1", "stage7.input.stage6.booleanity.BytecodeRa_2", "stage7.input.stage6.booleanity.RamRa_0", "stage7.input.stage6.booleanity.RamRa_1", "stage7.input.stage6.booleanity.RamRa_2", "stage7.input.stage6.booleanity.RamRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_0", "stage7.input.stage6.ram_ra_virtual.RamRa_1", "stage7.input.stage6.ram_ra_virtual.RamRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.claim_expr", Stage7ValueExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), + stage7_value_expr("stage7.hamming_weight_claim_reduction.input.claim_expr", Stage7ValueExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[], shared_term_offsets: &[], row_term_offsets: &[0, 1, 2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.booleanity.InstructionRa_0", "stage7.input.stage6.booleanity.InstructionRa_1", "stage7.input.stage6.booleanity.InstructionRa_2", "stage7.input.stage6.booleanity.InstructionRa_3", "stage7.input.stage6.booleanity.InstructionRa_4", "stage7.input.stage6.booleanity.InstructionRa_5", "stage7.input.stage6.booleanity.InstructionRa_6", "stage7.input.stage6.booleanity.InstructionRa_7", "stage7.input.stage6.booleanity.InstructionRa_8", "stage7.input.stage6.booleanity.InstructionRa_9", "stage7.input.stage6.booleanity.InstructionRa_10", "stage7.input.stage6.booleanity.InstructionRa_11", "stage7.input.stage6.booleanity.InstructionRa_12", "stage7.input.stage6.booleanity.InstructionRa_13", "stage7.input.stage6.booleanity.InstructionRa_14", "stage7.input.stage6.booleanity.InstructionRa_15", "stage7.input.stage6.booleanity.InstructionRa_16", "stage7.input.stage6.booleanity.InstructionRa_17", "stage7.input.stage6.booleanity.InstructionRa_18", "stage7.input.stage6.booleanity.InstructionRa_19", "stage7.input.stage6.booleanity.InstructionRa_20", "stage7.input.stage6.booleanity.InstructionRa_21", "stage7.input.stage6.booleanity.InstructionRa_22", "stage7.input.stage6.booleanity.InstructionRa_23", "stage7.input.stage6.booleanity.InstructionRa_24", "stage7.input.stage6.booleanity.InstructionRa_25", "stage7.input.stage6.booleanity.InstructionRa_26", "stage7.input.stage6.booleanity.InstructionRa_27", "stage7.input.stage6.booleanity.InstructionRa_28", "stage7.input.stage6.booleanity.InstructionRa_29", "stage7.input.stage6.booleanity.InstructionRa_30", "stage7.input.stage6.booleanity.InstructionRa_31", "stage7.input.stage6.booleanity.BytecodeRa_0", "stage7.input.stage6.booleanity.BytecodeRa_1", "stage7.input.stage6.booleanity.BytecodeRa_2", "stage7.input.stage6.booleanity.RamRa_0", "stage7.input.stage6.booleanity.RamRa_1", "stage7.input.stage6.booleanity.RamRa_2", "stage7.input.stage6.booleanity.RamRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_0", "stage7.input.stage6.ram_ra_virtual.RamRa_1", "stage7.input.stage6.ram_ra_virtual.RamRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.claim_expr", Stage7ValueExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.Booleanity", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.booleanity.InstructionRa_0"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"]), + stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"]), + stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"]), + stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"]), + stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_0"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_1"]), + stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_2"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), ]; pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ @@ -663,7 +668,6 @@ fn expected_batched_output_claim( Stage7RelationKind::Stage7HammingWeightClaimReduction => { bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, - program.relation_output_values, program.field_exprs, program.value_exprs, store, From 2ba92ddf857212445b27e1d17163d5690ae7b1f7 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 23:12:08 -0600 Subject: [PATCH 109/171] refactor(bolt): share value expr validation Add a shared verifier value-expression operand validator and use it from Stages 3 through 7. This closes the Stage 3/4 structured-polynomial validation gap and removes duplicated scalar, point, and field-vector checks from the later stages. Verification: - cargo check -p bolt --quiet - cargo nextest run -p bolt rust_target_plan stage7_rust_targets_extract_and_compile verifier_relation_outputs generated_jolt_artifacts_have_uniform_crate_layout_and_import_rules --cargo-quiet - cargo clippy -p bolt --all-targets -q -- -D warnings - git diff --check --- .../protocols/jolt/emit/rust/plan_tokens.rs | 80 ++++++++++++++++++- .../src/protocols/jolt/emit/rust/stage3.rs | 19 +++++ .../src/protocols/jolt/emit/rust/stage4.rs | 19 +++++ .../src/protocols/jolt/emit/rust/stage5.rs | 67 +++------------- .../src/protocols/jolt/emit/rust/stage6.rs | 67 +++------------- .../src/protocols/jolt/emit/rust/stage7.rs | 55 +++---------- 6 files changed, 150 insertions(+), 157 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index 556749b2f5..ce7a17793b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -4,7 +4,10 @@ use crate::emit::rust::EmitError; use crate::ir::Role; use crate::protocols::jolt::rust_target_plan::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode, - ProgramStepKind, RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, + ProgramStepKind, RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, ValueExprKind, +}; +use crate::protocols::jolt::verifier_values::{ + VerifierFieldVectorSourceSet, VerifierPointSourceSet, VerifierScalarSourceSet, }; pub(super) fn role_program_step_kind_expr( @@ -149,6 +152,81 @@ pub(super) fn symbols<'a>(values: impl Iterator) -> BTreeSet< values.cloned().collect() } +pub(super) struct ValueExprVerification<'a> { + pub stage: &'static str, + pub symbol: &'a str, + pub formula: &'a str, + pub operand_names: &'a [String], + pub operands: &'a [String], + pub field_values: &'a VerifierScalarSourceSet, + pub field_vector_values: Option<&'a VerifierFieldVectorSourceSet>, + pub point_values: Option<&'a VerifierPointSourceSet>, +} + +pub(super) fn verify_value_expr_operands( + verification: ValueExprVerification<'_>, +) -> Result<(), EmitError> { + let ValueExprVerification { + stage, + symbol, + formula, + operand_names, + operands, + field_values, + field_vector_values, + point_values, + } = verification; + verify_count( + "value expr operands", + symbol, + operand_names.len(), + operands.len(), + )?; + let kind = + ValueExprKind::from_cpu_attr(formula).map_err(|error| EmitError::new(error.to_string()))?; + match kind { + ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { + let Some(field_vector_values) = field_vector_values else { + return Err(EmitError::new(format!( + "{stage} value expr @{symbol} uses unsupported field-vector formula `{formula}`" + ))); + }; + verify_count("field vector expr operands", symbol, 1, operands.len())?; + let operand = &operands[0]; + if !field_vector_values.contains(operand) { + return Err(EmitError::new(format!( + "field vector expr @{symbol} references missing field vector @{operand}" + ))); + } + } + ValueExprKind::PowerStridedWeightedSum { .. } => { + for operand in operands { + if !field_values.contains(operand) { + return Err(EmitError::new(format!( + "value expr @{symbol} references missing field value @{operand}" + ))); + } + } + } + ValueExprKind::StructuredPolynomial { .. } => { + verify_count( + "structured polynomial value expr operands", + symbol, + 2, + operands.len(), + )?; + for operand in operands { + if !point_values.is_some_and(|values| values.contains(operand)) { + return Err(EmitError::new(format!( + "structured polynomial value expr @{symbol} references missing point value @{operand}" + ))); + } + } + } + } + Ok(()) +} + pub(super) fn role_relation_kind_expr( stage_type_prefix: &str, role: &Role, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 85ae9a3ae7..adef92100c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -725,6 +725,11 @@ impl Stage3CpuProgram { } else { self.cpu_field_value_sources() }; + let point_values = if self.role == Role::Verifier { + Some(self.verifier_plan()?.point_value_sources()) + } else { + None + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -741,6 +746,20 @@ impl Stage3CpuProgram { } } } + for expr in &self.value_exprs { + super::plan_tokens::verify_value_expr_operands( + super::plan_tokens::ValueExprVerification { + stage: "stage3", + symbol: &expr.symbol, + formula: &expr.formula, + operand_names: &expr.operand_names, + operands: &expr.operands, + field_values: &field_values, + field_vector_values: None, + point_values: point_values.as_ref(), + }, + )?; + } for claim in &self.claims { if !field_values.contains(&claim.claim_value) { return Err(EmitError::new(format!( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index a7c24d9a85..b1f411c2df 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -746,6 +746,11 @@ impl Stage4CpuProgram { } else { self.cpu_field_value_sources() }; + let point_values = if self.role == Role::Verifier { + Some(self.verifier_plan()?.point_value_sources()) + } else { + None + }; for expr in &self.field_exprs { verify_count( "field expr operands", @@ -762,6 +767,20 @@ impl Stage4CpuProgram { } } } + for expr in &self.value_exprs { + super::plan_tokens::verify_value_expr_operands( + super::plan_tokens::ValueExprVerification { + stage: "stage4", + symbol: &expr.symbol, + formula: &expr.formula, + operand_names: &expr.operand_names, + operands: &expr.operands, + field_values: &field_values, + field_vector_values: None, + point_values: point_values.as_ref(), + }, + )?; + } for claim in &self.claims { if !field_values.contains(&claim.claim_value) { return Err(EmitError::new(format!( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 483ffe1d29..8e6e3db735 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -856,63 +856,18 @@ impl Stage5CpuProgram { } } for expr in &self.value_exprs { - verify_count( - "value expr operands", - &expr.symbol, - expr.operand_names.len(), - expr.operands.len(), + super::plan_tokens::verify_value_expr_operands( + super::plan_tokens::ValueExprVerification { + stage: "stage5", + symbol: &expr.symbol, + formula: &expr.formula, + operand_names: &expr.operand_names, + operands: &expr.operands, + field_values: &field_values, + field_vector_values: field_vector_values.as_ref(), + point_values: point_values.as_ref(), + }, )?; - let kind = ValueExprKind::from_cpu_attr(&expr.formula) - .map_err(|error| EmitError::new(error.to_string()))?; - match kind { - ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { - verify_count( - "field vector expr operands", - &expr.symbol, - 1, - expr.operands.len(), - )?; - let operand = &expr.operands[0]; - if !field_vector_values - .as_ref() - .is_some_and(|values| values.contains(operand)) - { - return Err(EmitError::new(format!( - "field vector expr @{} references missing field vector @{operand}", - expr.symbol - ))); - } - } - ValueExprKind::PowerStridedWeightedSum { .. } => { - for operand in &expr.operands { - if !field_values.contains(operand) { - return Err(EmitError::new(format!( - "value expr @{} references missing field value @{operand}", - expr.symbol - ))); - } - } - } - ValueExprKind::StructuredPolynomial { .. } => { - verify_count( - "structured polynomial value expr operands", - &expr.symbol, - 2, - expr.operands.len(), - )?; - for operand in &expr.operands { - if !point_values - .as_ref() - .is_some_and(|values| values.contains(operand)) - { - return Err(EmitError::new(format!( - "structured polynomial value expr @{} references missing point value @{operand}", - expr.symbol - ))); - } - } - } - } } for claim in &self.claims { if !field_values.contains(&claim.claim_value) { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index df6eca79b5..221d55b6dc 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -866,63 +866,18 @@ impl Stage6CpuProgram { } } for expr in &self.value_exprs { - verify_count( - "value expr operands", - &expr.symbol, - expr.operand_names.len(), - expr.operands.len(), + super::plan_tokens::verify_value_expr_operands( + super::plan_tokens::ValueExprVerification { + stage: "stage6", + symbol: &expr.symbol, + formula: &expr.formula, + operand_names: &expr.operand_names, + operands: &expr.operands, + field_values: &field_values, + field_vector_values: field_vector_values.as_ref(), + point_values: point_values.as_ref(), + }, )?; - let kind = ValueExprKind::from_cpu_attr(&expr.formula) - .map_err(|error| EmitError::new(error.to_string()))?; - match kind { - ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { - verify_count( - "field vector expr operands", - &expr.symbol, - 1, - expr.operands.len(), - )?; - let operand = &expr.operands[0]; - if !field_vector_values - .as_ref() - .is_some_and(|values| values.contains(operand)) - { - return Err(EmitError::new(format!( - "field vector expr @{} references missing field vector @{operand}", - expr.symbol - ))); - } - } - ValueExprKind::PowerStridedWeightedSum { .. } => { - for operand in &expr.operands { - if !field_values.contains(operand) { - return Err(EmitError::new(format!( - "value expr @{} references missing field value @{operand}", - expr.symbol - ))); - } - } - } - ValueExprKind::StructuredPolynomial { .. } => { - verify_count( - "structured polynomial value expr operands", - &expr.symbol, - 2, - expr.operands.len(), - )?; - for operand in &expr.operands { - if !point_values - .as_ref() - .is_some_and(|values| values.contains(operand)) - { - return Err(EmitError::new(format!( - "structured polynomial value expr @{} references missing point value @{operand}", - expr.symbol - ))); - } - } - } - } } for claim in &self.claims { if !field_values.contains(&claim.claim_value) { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index ac5be47c41..a7bd69bc99 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -999,51 +999,18 @@ impl Stage7CpuProgram { } } for expr in &self.value_exprs { - verify_count( - "value expr operands", - &expr.symbol, - expr.operand_names.len(), - expr.operands.len(), + super::plan_tokens::verify_value_expr_operands( + super::plan_tokens::ValueExprVerification { + stage: "stage7", + symbol: &expr.symbol, + formula: &expr.formula, + operand_names: &expr.operand_names, + operands: &expr.operands, + field_values: &field_values, + field_vector_values: None, + point_values: point_values.as_ref(), + }, )?; - let kind = ValueExprKind::from_cpu_attr(&expr.formula) - .map_err(|error| EmitError::new(error.to_string()))?; - match kind { - ValueExprKind::PowerStridedWeightedSum { .. } => { - for operand in &expr.operands { - if !field_values.contains(operand) { - return Err(EmitError::new(format!( - "value expr @{} references missing field value @{operand}", - expr.symbol - ))); - } - } - } - ValueExprKind::StructuredPolynomial { .. } => { - verify_count( - "structured polynomial value expr operands", - &expr.symbol, - 2, - expr.operands.len(), - )?; - for operand in &expr.operands { - if !point_values - .as_ref() - .is_some_and(|values| values.contains(operand)) - { - return Err(EmitError::new(format!( - "structured polynomial value expr @{} references missing point value @{operand}", - expr.symbol - ))); - } - } - } - ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { - return Err(EmitError::new(format!( - "stage7 value expr @{} uses unsupported field-vector formula `{}`", - expr.symbol, expr.formula - ))); - } - } } for claim in &self.claims { if !field_values.contains(&claim.claim_value) { From 71a2d41527af5bf2922a1e9e03ed2fa9798a0249 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Fri, 15 May 2026 23:26:21 -0600 Subject: [PATCH 110/171] refactor(bolt): name scalar verifier expressions --- crates/bolt-verifier-runtime/src/lib.rs | 117 +++++++++--------- .../protocols/jolt/emit/rust/plan_tokens.rs | 31 ++--- .../src/protocols/jolt/emit/rust/stage2.rs | 8 +- .../src/protocols/jolt/emit/rust/stage3.rs | 56 ++++----- .../src/protocols/jolt/emit/rust/stage4.rs | 60 ++++----- .../src/protocols/jolt/emit/rust/stage5.rs | 70 +++++------ .../src/protocols/jolt/emit/rust/stage6.rs | 70 +++++------ .../src/protocols/jolt/emit/rust/stage7.rs | 76 ++++++------ .../src/protocols/jolt/rust_target_plan.rs | 62 +++++----- .../bolt/src/protocols/jolt/verifier_plan.rs | 58 ++++----- .../src/protocols/jolt/verifier_values.rs | 2 +- crates/bolt/tests/commitment_ir.rs | 10 +- crates/jolt-equivalence/src/plan_adapters.rs | 52 ++++---- .../src/plan_adapters/generated_stage2.rs | 2 +- .../src/plan_adapters/generated_stage3.rs | 2 +- .../src/plan_adapters/generated_stage4.rs | 2 +- .../src/plan_adapters/generated_stage5.rs | 2 +- .../src/plan_adapters/generated_stage6.rs | 2 +- .../src/plan_adapters/generated_stage7.rs | 2 +- crates/jolt-verifier/src/stages/stage2.rs | 8 +- crates/jolt-verifier/src/stages/stage3.rs | 24 ++-- crates/jolt-verifier/src/stages/stage4.rs | 20 +-- crates/jolt-verifier/src/stages/stage5.rs | 30 ++--- crates/jolt-verifier/src/stages/stage6.rs | 22 ++-- crates/jolt-verifier/src/stages/stage7.rs | 32 ++--- 25 files changed, 411 insertions(+), 409 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 7ac9ef6466..ebfa3ef1aa 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -259,7 +259,7 @@ pub struct FieldExprPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum ValueExprKind { +pub enum ScalarExprKind { FieldVectorSum, FieldVectorProduct, StructuredPolynomial { @@ -277,9 +277,9 @@ pub enum ValueExprKind { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct ValueExprPlan { +pub struct ScalarExprPlan { pub symbol: &'static str, - pub kind: ValueExprKind, + pub kind: ScalarExprKind, pub operands: &'static [&'static str], } @@ -504,7 +504,7 @@ pub struct StageProgramPlan { pub opening_inputs: &'static [OpeningInputPlan], pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], - pub value_exprs: &'static [ValueExprPlan], + pub scalar_exprs: &'static [ScalarExprPlan], pub kernels: &'static [KernelPlan], pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], @@ -531,7 +531,7 @@ pub struct StageProgramPlanNoPointZeros { pub opening_inputs: &'static [OpeningInputPlan], pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], - pub value_exprs: &'static [ValueExprPlan], + pub scalar_exprs: &'static [ScalarExprPlan], pub kernels: &'static [KernelPlan], pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], @@ -555,7 +555,7 @@ pub struct StageVerifierProgramPlan { pub opening_inputs: &'static [OpeningInputPlan], pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], - pub value_exprs: &'static [ValueExprPlan], + pub scalar_exprs: &'static [ScalarExprPlan], pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], pub drivers: &'static [SumcheckDriverPlan], @@ -578,7 +578,7 @@ pub struct StageVerifierProgramPlanNoEqualities { pub opening_inputs: &'static [OpeningInputPlan], pub field_constants: &'static [FieldConstantPlan], pub field_exprs: &'static [FieldExprPlan], - pub value_exprs: &'static [ValueExprPlan], + pub scalar_exprs: &'static [ScalarExprPlan], pub claims: &'static [SumcheckClaimPlan], pub batches: &'static [SumcheckBatchPlan], pub drivers: &'static [SumcheckDriverPlan], @@ -993,7 +993,7 @@ impl ValueStore { pub fn evaluate_available_exprs( &mut self, field_exprs: &[FieldExprPlan], - value_exprs: &[ValueExprPlan], + scalar_exprs: &[ScalarExprPlan], ) -> Result<(), RuntimePlanError> { loop { let mut progress = 0usize; @@ -1007,14 +1007,14 @@ impl ValueStore { self.insert_scalar(expr.symbol, evaluate_field_expr(expr, &operands)?); progress += 1; } - for expr in value_exprs { + for expr in scalar_exprs { if self.try_scalar(expr.symbol).is_some() { continue; } - let Some(operands) = self.try_value_expr_operands(expr) else { + let Some(operands) = self.try_scalar_expr_operands(expr) else { continue; }; - self.insert_scalar(expr.symbol, evaluate_value_expr(expr, &operands)?); + self.insert_scalar(expr.symbol, evaluate_scalar_expr(expr, &operands)?); progress += 1; } if progress == 0 { @@ -1150,16 +1150,16 @@ impl ValueStore { .collect() } - fn try_value_expr_operands(&self, expr: &ValueExprPlan) -> Option> { + fn try_scalar_expr_operands(&self, expr: &ScalarExprPlan) -> Option> { match expr.kind { - ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { + ScalarExprKind::FieldVectorSum | ScalarExprKind::FieldVectorProduct => { let [symbol] = expr.operands else { return Some(Vec::new()); }; self.try_field_vector(symbol).map(|values| values.to_vec()) } - ValueExprKind::StructuredPolynomial { .. } => None, - ValueExprKind::PowerStridedWeightedSum { .. } => expr + ScalarExprKind::StructuredPolynomial { .. } => None, + ScalarExprKind::PowerStridedWeightedSum { .. } => expr .operands .iter() .map(|operand| self.try_scalar(operand)) @@ -1208,13 +1208,13 @@ pub fn batch_claims<'a, C: SymbolPlan>( pub fn batch_claim_values( claims: &[&C], field_exprs: &[FieldExprPlan], - value_exprs: &[ValueExprPlan], + scalar_exprs: &[ScalarExprPlan], store: &mut ValueStore, ) -> Result, RuntimePlanError> { claims .iter() .map(|claim| { - store.evaluate_available_exprs(field_exprs, value_exprs)?; + store.evaluate_available_exprs(field_exprs, scalar_exprs)?; store.scalar_or(claim.claim_value(), |symbol| { RuntimePlanError::MissingValue { symbol } }) @@ -1228,7 +1228,7 @@ pub fn verify_batched_sumcheck( claims: &'static [C], batches: &'static [SumcheckBatchPlan], field_exprs: &'static [FieldExprPlan], - value_exprs: &'static [ValueExprPlan], + scalar_exprs: &'static [ScalarExprPlan], opening_inputs: &'static [OpeningInputPlan], opening_claims: &'static [OpeningClaimPlan], opening_batches: &'static [OpeningBatchPlan], @@ -1256,7 +1256,7 @@ where } let batch = find_batch(batches, driver.symbol(), driver.batch())?; let claims = batch_claims(claims, batch)?; - let input_claims = batch_claim_values(&claims, field_exprs, value_exprs, store)?; + let input_claims = batch_claim_values(&claims, field_exprs, scalar_exprs, store)?; for claim in &input_claims { append_labeled_scalar(transcript, batch.claim_label, claim); } @@ -1338,7 +1338,7 @@ pub fn eval_family_values( pub fn evaluate_relation_output( plan: &RelationOutputPlan, field_exprs: &[FieldExprPlan], - value_exprs: &[ValueExprPlan], + scalar_exprs: &[ScalarExprPlan], store: &ValueStore, instance_symbol: &'static str, evals: &[StageNamedEval], @@ -1363,7 +1363,7 @@ pub fn evaluate_relation_output( local_points, local_point, }; - evaluate_available_exprs_with_scratch(field_exprs, value_exprs, store, &mut scratch, context)?; + evaluate_available_exprs_with_scratch(field_exprs, scalar_exprs, store, &mut scratch, context)?; scratch .scalar_or(store, plan.expected_output) .ok_or(RuntimePlanError::MissingValue { @@ -1374,7 +1374,7 @@ pub fn evaluate_relation_output( pub fn evaluate_relation_output_for_instance( relation_outputs: &[RelationOutputPlan], field_exprs: &[FieldExprPlan], - value_exprs: &[ValueExprPlan], + scalar_exprs: &[ScalarExprPlan], store: &ValueStore, instance: &SumcheckInstanceResultPlan, evals: &[StageNamedEval], @@ -1392,7 +1392,7 @@ pub fn evaluate_relation_output_for_instance( evaluate_relation_output( relation_output, field_exprs, - value_exprs, + scalar_exprs, store, instance.symbol, evals, @@ -1509,7 +1509,7 @@ impl ScratchScalars { fn evaluate_available_exprs_with_scratch( field_exprs: &[FieldExprPlan], - value_exprs: &[ValueExprPlan], + scalar_exprs: &[ScalarExprPlan], store: &ValueStore, scratch: &mut ScratchScalars, context: RelationOutputContext<'_>, @@ -1526,11 +1526,11 @@ fn evaluate_available_exprs_with_scratch( scratch.insert(expr.symbol, evaluate_field_expr(expr, &operands)?); progress += 1; } - for expr in value_exprs { + for expr in scalar_exprs { if scratch.scalar_or(store, expr.symbol).is_some() { continue; } - let Some(value) = evaluate_relation_output_value_expr(expr, store, scratch, context)? + let Some(value) = evaluate_relation_output_scalar_expr(expr, store, scratch, context)? else { continue; }; @@ -1554,27 +1554,27 @@ fn relation_output_expr_operands( .collect() } -fn evaluate_relation_output_value_expr( - expr: &ValueExprPlan, +fn evaluate_relation_output_scalar_expr( + expr: &ScalarExprPlan, store: &ValueStore, scratch: &ScratchScalars, context: RelationOutputContext<'_>, ) -> Result, RuntimePlanError> { match expr.kind { - ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { + ScalarExprKind::FieldVectorSum | ScalarExprKind::FieldVectorProduct => { let [symbol] = expr.operands else { - return evaluate_value_expr(expr, &[]).map(Some); + return evaluate_scalar_expr(expr, &[]).map(Some); }; let Some(values) = store.try_field_vector(symbol) else { return Ok(None); }; - evaluate_value_expr(expr, values).map(Some) + evaluate_scalar_expr(expr, values).map(Some) } - ValueExprKind::StructuredPolynomial { + ScalarExprKind::StructuredPolynomial { polynomial, x_point, y_point, - } => evaluate_structured_polynomial_value( + } => evaluate_structured_polynomial_scalar( expr.symbol, expr.operands, polynomial, @@ -1584,18 +1584,18 @@ fn evaluate_relation_output_value_expr( context, ) .map(Some), - ValueExprKind::PowerStridedWeightedSum { .. } => expr + ScalarExprKind::PowerStridedWeightedSum { .. } => expr .operands .iter() .map(|operand| scratch.scalar_or(store, operand)) .collect::>>() - .map(|operands| evaluate_value_expr(expr, &operands).map(Some)) + .map(|operands| evaluate_scalar_expr(expr, &operands).map(Some)) .transpose() .map(Option::flatten), } } -fn evaluate_structured_polynomial_value( +fn evaluate_structured_polynomial_scalar( symbol: &'static str, operands: &[&'static str], polynomial: StructuredPolynomialKind, @@ -1730,30 +1730,31 @@ pub fn evaluate_field_expr( } } -pub fn evaluate_value_expr( - expr: &ValueExprPlan, +pub fn evaluate_scalar_expr( + expr: &ScalarExprPlan, operands: &[F], ) -> Result { match expr.kind { - ValueExprKind::FieldVectorSum => { + ScalarExprKind::FieldVectorSum => { require_min_operand_count(expr.symbol, 1, operands.len())?; Ok(operands .iter() .copied() .fold(F::from_u64(0), |acc, operand| acc + operand)) } - ValueExprKind::FieldVectorProduct => { + ScalarExprKind::FieldVectorProduct => { require_min_operand_count(expr.symbol, 1, operands.len())?; Ok(operands .iter() .copied() .fold(F::from_u64(1), |acc, operand| acc * operand)) } - ValueExprKind::StructuredPolynomial { .. } => Err(RuntimePlanError::InvalidProof { + ScalarExprKind::StructuredPolynomial { .. } => Err(RuntimePlanError::InvalidProof { driver: expr.symbol, - reason: "structured polynomial value expressions require relation-output point context", + reason: + "structured polynomial scalar expressions require relation-output point context", }), - ValueExprKind::PowerStridedWeightedSum { + ScalarExprKind::PowerStridedWeightedSum { row_count, power_stride, value_term_offsets, @@ -1964,11 +1965,11 @@ pub fn reverse_slice(values: &[Fr]) -> Vec { )] mod tests { use super::{ - evaluate_relation_output_for_instance, evaluate_value_expr, Fr, NamedEvalFamilyPlan, - RelationOutputPlan, RuntimePlanError, StructuredPolynomialKind, - StructuredPolynomialPointLength, StructuredPolynomialPointOrder, + evaluate_relation_output_for_instance, evaluate_scalar_expr, Fr, NamedEvalFamilyPlan, + RelationOutputPlan, RuntimePlanError, ScalarExprKind, ScalarExprPlan, + StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointSegment, StructuredPolynomialPointTransform, - SumcheckInstanceResultPlan, SumcheckPointOrder, ValueExprKind, ValueExprPlan, ValueStore, + SumcheckInstanceResultPlan, SumcheckPointOrder, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -2022,14 +2023,14 @@ mod tests { .evaluate_available_exprs( &[], &[ - ValueExprPlan { + ScalarExprPlan { symbol: "family.ab.product", - kind: ValueExprKind::FieldVectorProduct, + kind: ScalarExprKind::FieldVectorProduct, operands: &["family.ab"], }, - ValueExprPlan { + ScalarExprPlan { symbol: "family.ab.sum", - kind: ValueExprKind::FieldVectorSum, + kind: ScalarExprKind::FieldVectorSum, operands: &["family.ab"], }, ], @@ -2041,11 +2042,11 @@ mod tests { } #[test] - fn value_expr_evaluates_power_strided_weighted_sum() { - let value = evaluate_value_expr( - &ValueExprPlan { + fn scalar_expr_evaluates_power_strided_weighted_sum() { + let value = evaluate_scalar_expr( + &ScalarExprPlan { symbol: "family.weighted", - kind: ValueExprKind::PowerStridedWeightedSum { + kind: ScalarExprKind::PowerStridedWeightedSum { row_count: 2, power_stride: 3, value_term_offsets: &[0], @@ -2069,7 +2070,7 @@ mod tests { } #[test] - fn relation_output_evaluates_structured_polynomial_value_exprs() { + fn relation_output_evaluates_structured_polynomial_scalar_exprs() { let x = [Fr::from_u64(1), Fr::from_u64(0)]; let mut store = ValueStore::default(); store.insert_point("point.y", x.to_vec()); @@ -2082,9 +2083,9 @@ mod tests { expected_output: "eq.xy", }], &[], - &[ValueExprPlan { + &[ScalarExprPlan { symbol: "eq.xy", - kind: ValueExprKind::StructuredPolynomial { + kind: ScalarExprKind::StructuredPolynomial { polynomial: StructuredPolynomialKind::Eq, x_point: StructuredPolynomialPointTransform { segment: StructuredPolynomialPointSegment::Full, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index ce7a17793b..938337964f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -4,7 +4,8 @@ use crate::emit::rust::EmitError; use crate::ir::Role; use crate::protocols::jolt::rust_target_plan::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode, - ProgramStepKind, RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, ValueExprKind, + ProgramStepKind, RustTargetPlanError, ScalarExprKind, SumcheckPointOrder, + TranscriptSqueezeKind, }; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorSourceSet, VerifierPointSourceSet, VerifierScalarSourceSet, @@ -152,7 +153,7 @@ pub(super) fn symbols<'a>(values: impl Iterator) -> BTreeSet< values.cloned().collect() } -pub(super) struct ValueExprVerification<'a> { +pub(super) struct ScalarExprVerification<'a> { pub stage: &'static str, pub symbol: &'a str, pub formula: &'a str, @@ -163,10 +164,10 @@ pub(super) struct ValueExprVerification<'a> { pub point_values: Option<&'a VerifierPointSourceSet>, } -pub(super) fn verify_value_expr_operands( - verification: ValueExprVerification<'_>, +pub(super) fn verify_scalar_expr_operands( + verification: ScalarExprVerification<'_>, ) -> Result<(), EmitError> { - let ValueExprVerification { + let ScalarExprVerification { stage, symbol, formula, @@ -177,18 +178,18 @@ pub(super) fn verify_value_expr_operands( point_values, } = verification; verify_count( - "value expr operands", + "scalar expr operands", symbol, operand_names.len(), operands.len(), )?; - let kind = - ValueExprKind::from_cpu_attr(formula).map_err(|error| EmitError::new(error.to_string()))?; + let kind = ScalarExprKind::from_cpu_attr(formula) + .map_err(|error| EmitError::new(error.to_string()))?; match kind { - ValueExprKind::FieldVectorSum | ValueExprKind::FieldVectorProduct => { + ScalarExprKind::FieldVectorSum | ScalarExprKind::FieldVectorProduct => { let Some(field_vector_values) = field_vector_values else { return Err(EmitError::new(format!( - "{stage} value expr @{symbol} uses unsupported field-vector formula `{formula}`" + "{stage} scalar expr @{symbol} uses unsupported field-vector formula `{formula}`" ))); }; verify_count("field vector expr operands", symbol, 1, operands.len())?; @@ -199,18 +200,18 @@ pub(super) fn verify_value_expr_operands( ))); } } - ValueExprKind::PowerStridedWeightedSum { .. } => { + ScalarExprKind::PowerStridedWeightedSum { .. } => { for operand in operands { if !field_values.contains(operand) { return Err(EmitError::new(format!( - "value expr @{symbol} references missing field value @{operand}" + "scalar expr @{symbol} references missing field value @{operand}" ))); } } } - ValueExprKind::StructuredPolynomial { .. } => { + ScalarExprKind::StructuredPolynomial { .. } => { verify_count( - "structured polynomial value expr operands", + "structured polynomial scalar expr operands", symbol, 2, operands.len(), @@ -218,7 +219,7 @@ pub(super) fn verify_value_expr_operands( for operand in operands { if !point_values.is_some_and(|values| values.contains(operand)) { return Err(EmitError::new(format!( - "structured polynomial value expr @{symbol} references missing point value @{operand}" + "structured polynomial scalar expr @{symbol} references missing point value @{operand}" ))); } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 14bc4eba7f..78bf12f593 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -1000,7 +1000,7 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage2ClaimKind, FieldConstantPlan as Stage2FieldConstantPlan, FieldExprKind as Stage2FieldExprKind, FieldExprPlan as Stage2FieldExprPlan, - ValueExprPlan as Stage2ValueExprPlan, + ScalarExprPlan as Stage2ScalarExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, OpeningInputPlan as Stage2OpeningInputPlan, PointConcatPlan as Stage2PointConcatPlan, PointSlicePlan as Stage2PointSlicePlan, ProgramStepKind as Stage2ProgramStepKind, @@ -1109,7 +1109,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); \x20 opening_inputs: STAGE2_OPENING_INPUTS,\n\ \x20 field_constants: STAGE2_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE2_FIELD_EXPRS,\n\ - \x20 value_exprs: STAGE2_VALUE_EXPRS,\n\ + \x20 scalar_exprs: STAGE2_SCALAR_EXPRS,\n\ \x20 claims: STAGE2_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE2_SUMCHECK_BATCHES,\n\ \x20 drivers: STAGE2_SUMCHECK_DRIVERS,\n\ @@ -1151,7 +1151,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); if self.role == Role::Verifier { - source.push_str("pub const STAGE2_VALUE_EXPRS: &[Stage2ValueExprPlan] = &[];\n"); + source.push_str("pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[];\n"); } Ok(source) } @@ -2165,7 +2165,7 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, ) -> Result<(), VerifyStage2Error> { self.0 - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage2Error::from) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index adef92100c..30f7586463 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -6,7 +6,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::structured_polynomial_value_formula; +use crate::protocols::jolt::rust_target_plan::structured_polynomial_scalar_formula; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, FieldExprDependencies, RelationOutputAst as Stage3RelationOutputAst, @@ -27,7 +27,7 @@ pub struct Stage3CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, - pub value_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -101,7 +101,7 @@ pub struct Stage3FieldExprPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3ValueExprPlan { +pub struct Stage3ScalarExprPlan { pub symbol: String, pub kind: String, pub formula: String, @@ -119,14 +119,14 @@ impl FieldExprDependencies for Stage3FieldExprPlan { } } -fn stage3_structured_polynomial_value_expr( +fn stage3_structured_polynomial_scalar_expr( value: &Stage3StructuredPolynomialEvalPlan, -) -> Stage3ValueExprPlan { +) -> Stage3ScalarExprPlan { let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; - Stage3ValueExprPlan { + Stage3ScalarExprPlan { symbol: value.symbol.clone(), kind: "op".to_owned(), - formula: structured_polynomial_value_formula( + formula: structured_polynomial_scalar_formula( value.polynomial.as_str(), value.x_point.segment.as_str(), value.x_point.length.as_str(), @@ -261,7 +261,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_input = Stage3OpeningInputPlan, field_constant = Stage3FieldConstantPlan, field_expr = Stage3FieldExprPlan, - value_expr = Stage3ValueExprPlan, + scalar_expr = Stage3ScalarExprPlan, claim = Stage3SumcheckClaimPlan, batch = Stage3SumcheckBatchPlan, driver = Stage3SumcheckDriverPlan, @@ -298,7 +298,7 @@ impl Stage3CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); - let mut value_exprs = Vec::new(); + let mut scalar_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -606,10 +606,10 @@ impl Stage3CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if is_verifier { - value_exprs.extend( + scalar_exprs.extend( relation_output_values .iter() - .map(stage3_structured_polynomial_value_expr), + .map(stage3_structured_polynomial_scalar_expr), ); } if role == Role::Prover { @@ -644,7 +644,7 @@ impl Stage3CpuProgram { opening_inputs, field_constants, field_exprs, - value_exprs, + scalar_exprs, kernels, claims, batches, @@ -746,9 +746,9 @@ impl Stage3CpuProgram { } } } - for expr in &self.value_exprs { - super::plan_tokens::verify_value_expr_operands( - super::plan_tokens::ValueExprVerification { + for expr in &self.scalar_exprs { + super::plan_tokens::verify_scalar_expr_operands( + super::plan_tokens::ScalarExprVerification { stage: "stage3", symbol: &expr.symbol, formula: &expr.formula, @@ -793,8 +793,8 @@ impl Stage3CpuProgram { verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.value_exprs.iter().map(|expr| &expr.symbol), - verifier_values::VerifierScalarSourceKind::ValueExpr, + self.scalar_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ScalarExpr, ); values.extend( self.evals.iter().map(|eval| &eval.symbol), @@ -1211,8 +1211,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage3ClaimKind, FieldConstantPlan as Stage3FieldConstantPlan, FieldExprKind as Stage3FieldExprKind, FieldExprPlan as Stage3FieldExprPlan, - ValueExprKind as Stage3ValueExprKind, - ValueExprPlan as Stage3ValueExprPlan, + ScalarExprKind as Stage3ScalarExprKind, + ScalarExprPlan as Stage3ScalarExprPlan, OpeningBatchPlan as Stage3OpeningBatchPlan, OpeningClaimEqualityPlan as Stage3OpeningClaimEqualityPlan, OpeningClaimPlan as Stage3OpeningClaimPlan, OpeningInputPlan as Stage3OpeningInputPlan, @@ -1293,7 +1293,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); \x20 opening_inputs: STAGE3_OPENING_INPUTS,\n\ \x20 field_constants: STAGE3_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE3_FIELD_EXPRS,\n\ - \x20 value_exprs: STAGE3_VALUE_EXPRS,\n\ + \x20 scalar_exprs: STAGE3_SCALAR_EXPRS,\n\ \x20 claims: STAGE3_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE3_SUMCHECK_BATCHES,\n\ \x20 drivers: STAGE3_SUMCHECK_DRIVERS,\n\ @@ -1328,7 +1328,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); if self.role == Role::Verifier { - source.push_str(&self.emit_value_expr_constants()?); + source.push_str(&self.emit_scalar_expr_constants()?); } Ok(source) } @@ -1495,12 +1495,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); Ok(source) } - fn emit_value_expr_constants(&self) -> Result { + fn emit_scalar_expr_constants(&self) -> Result { let plan = self.verifier_plan()?; - Ok(verifier_plan::emit_value_expr_constants( + Ok(verifier_plan::emit_scalar_expr_constants( "Stage3", "STAGE3", - &plan.value_exprs, + &plan.scalar_exprs, )) } @@ -2091,7 +2091,7 @@ where } })?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage3Error::from)?; artifacts.challenge_vectors.push(Stage3ChallengeVector { symbol: squeeze.symbol, @@ -2158,7 +2158,7 @@ where program.claims, program.batches, program.field_exprs, - program.value_exprs, + program.scalar_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -2211,7 +2211,7 @@ fn observe_stage3_sumcheck_output( }, )?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage3Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2250,7 +2250,7 @@ fn expected_batched_output_claim( let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index b1f411c2df..7f68314fb6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -11,7 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::structured_polynomial_value_formula; +use crate::protocols::jolt::rust_target_plan::structured_polynomial_scalar_formula; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, FieldExprDependencies, RelationOutputAst as Stage4RelationOutputAst, @@ -33,7 +33,7 @@ pub struct Stage4CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, - pub value_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -114,7 +114,7 @@ pub struct Stage4FieldExprPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4ValueExprPlan { +pub struct Stage4ScalarExprPlan { pub symbol: String, pub kind: String, pub formula: String, @@ -132,14 +132,14 @@ impl FieldExprDependencies for Stage4FieldExprPlan { } } -fn stage4_structured_polynomial_value_expr( +fn stage4_structured_polynomial_scalar_expr( value: &Stage4StructuredPolynomialEvalPlan, -) -> Stage4ValueExprPlan { +) -> Stage4ScalarExprPlan { let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; - Stage4ValueExprPlan { + Stage4ScalarExprPlan { symbol: value.symbol.clone(), kind: "op".to_owned(), - formula: structured_polynomial_value_formula( + formula: structured_polynomial_scalar_formula( value.polynomial.as_str(), value.x_point.segment.as_str(), value.x_point.length.as_str(), @@ -274,7 +274,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_input = Stage4OpeningInputPlan, field_constant = Stage4FieldConstantPlan, field_expr = Stage4FieldExprPlan, - value_expr = Stage4ValueExprPlan, + scalar_expr = Stage4ScalarExprPlan, claim = Stage4SumcheckClaimPlan, batch = Stage4SumcheckBatchPlan, driver = Stage4SumcheckDriverPlan, @@ -313,7 +313,7 @@ impl Stage4CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); - let mut value_exprs = Vec::new(); + let mut scalar_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -618,10 +618,10 @@ impl Stage4CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; let is_verifier = role == Role::Verifier; if is_verifier { - value_exprs.extend( + scalar_exprs.extend( relation_output_values .iter() - .map(stage4_structured_polynomial_value_expr), + .map(stage4_structured_polynomial_scalar_expr), ); } if role == Role::Prover { @@ -657,7 +657,7 @@ impl Stage4CpuProgram { opening_inputs, field_constants, field_exprs, - value_exprs, + scalar_exprs, kernels, claims, batches, @@ -767,9 +767,9 @@ impl Stage4CpuProgram { } } } - for expr in &self.value_exprs { - super::plan_tokens::verify_value_expr_operands( - super::plan_tokens::ValueExprVerification { + for expr in &self.scalar_exprs { + super::plan_tokens::verify_scalar_expr_operands( + super::plan_tokens::ScalarExprVerification { stage: "stage4", symbol: &expr.symbol, formula: &expr.formula, @@ -814,8 +814,8 @@ impl Stage4CpuProgram { verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.value_exprs.iter().map(|expr| &expr.symbol), - verifier_values::VerifierScalarSourceKind::ValueExpr, + self.scalar_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ScalarExpr, ); values.extend( self.evals.iter().map(|eval| &eval.symbol), @@ -1423,8 +1423,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage4ClaimKind, FieldConstantPlan as Stage4FieldConstantPlan, FieldExprKind as Stage4FieldExprKind, FieldExprPlan as Stage4FieldExprPlan, - ValueExprKind as Stage4ValueExprKind, - ValueExprPlan as Stage4ValueExprPlan, + ScalarExprKind as Stage4ScalarExprKind, + ScalarExprPlan as Stage4ScalarExprPlan, KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan, OpeningClaimEqualityPlan as Stage4OpeningClaimEqualityPlan, OpeningClaimPlan as Stage4OpeningClaimPlan, OpeningInputPlan as Stage4OpeningInputPlan, @@ -1487,8 +1487,8 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } else { "" }; - let value_exprs_field = if self.role == Role::Verifier { - " value_exprs: STAGE4_VALUE_EXPRS,\n" + let scalar_exprs_field = if self.role == Role::Verifier { + " scalar_exprs: STAGE4_SCALAR_EXPRS,\n" } else { "" }; @@ -1504,7 +1504,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); \x20 opening_inputs: STAGE4_OPENING_INPUTS,\n\ \x20 field_constants: STAGE4_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE4_FIELD_EXPRS,\n\ - {value_exprs_field}\ + {scalar_exprs_field}\ \x20 kernels: STAGE4_KERNELS,\n\ \x20 claims: STAGE4_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE4_SUMCHECK_BATCHES,\n\ @@ -1543,7 +1543,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); if self.role == Role::Verifier { - source.push_str(&self.emit_value_expr_constants()?); + source.push_str(&self.emit_scalar_expr_constants()?); } Ok(source) } @@ -1733,12 +1733,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); Ok(source) } - fn emit_value_expr_constants(&self) -> Result { + fn emit_scalar_expr_constants(&self) -> Result { let plan = self.verifier_plan()?; - Ok(verifier_plan::emit_value_expr_constants( + Ok(verifier_plan::emit_scalar_expr_constants( "Stage4", "STAGE4", - &plan.value_exprs, + &plan.scalar_exprs, )) } @@ -2323,7 +2323,7 @@ where } })?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage4Error::from)?; artifacts.challenge_vectors.push(Stage4ChallengeVector { symbol: squeeze.symbol, @@ -2401,7 +2401,7 @@ where program.claims, program.batches, program.field_exprs, - program.value_exprs, + program.scalar_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -2457,7 +2457,7 @@ fn observe_stage4_sumcheck_output( }, )?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage4Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2496,7 +2496,7 @@ fn expected_batched_output_claim( let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 8e6e3db735..edf17c059c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -12,7 +12,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::rust_target_plan::{ - structured_polynomial_value_formula, FieldExprKind, ValueExprKind, + structured_polynomial_scalar_formula, FieldExprKind, ScalarExprKind, }; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, @@ -45,7 +45,7 @@ pub struct Stage5CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, - pub value_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -129,7 +129,7 @@ pub struct Stage5FieldExprPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5ValueExprPlan { +pub struct Stage5ScalarExprPlan { pub symbol: String, pub kind: String, pub formula: String, @@ -224,8 +224,8 @@ fn stage5_field_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage } } -fn stage5_value_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage5ValueExprPlan { - Stage5ValueExprPlan { +fn stage5_scalar_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage5ScalarExprPlan { + Stage5ScalarExprPlan { symbol: expr.symbol, kind: "op".to_owned(), formula: expr.formula, @@ -234,14 +234,14 @@ fn stage5_value_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage } } -fn stage5_structured_polynomial_value_expr( +fn stage5_structured_polynomial_scalar_expr( value: &Stage5StructuredPolynomialEvalPlan, -) -> Stage5ValueExprPlan { +) -> Stage5ScalarExprPlan { let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; - Stage5ValueExprPlan { + Stage5ScalarExprPlan { symbol: value.symbol.clone(), kind: "op".to_owned(), - formula: structured_polynomial_value_formula( + formula: structured_polynomial_scalar_formula( value.polynomial.as_str(), value.x_point.segment.as_str(), value.x_point.length.as_str(), @@ -309,7 +309,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_input = Stage5OpeningInputPlan, field_constant = Stage5FieldConstantPlan, field_expr = Stage5FieldExprPlan, - value_expr = Stage5ValueExprPlan, + scalar_expr = Stage5ScalarExprPlan, claim = Stage5SumcheckClaimPlan, batch = Stage5SumcheckBatchPlan, driver = Stage5SumcheckDriverPlan, @@ -352,7 +352,7 @@ impl Stage5CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); - let mut value_exprs = Vec::new(); + let mut scalar_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -708,8 +708,8 @@ impl Stage5CpuProgram { } relation_output_values.extend(output_plan.relation_output_values); for expr in output_plan.field_exprs { - if ValueExprKind::from_cpu_attr(&expr.formula).is_ok() { - value_exprs.push(stage5_value_expr(expr)); + if ScalarExprKind::from_cpu_attr(&expr.formula).is_ok() { + scalar_exprs.push(stage5_scalar_expr(expr)); } else { field_exprs.push(stage5_field_expr(expr)); } @@ -717,10 +717,10 @@ impl Stage5CpuProgram { relation_outputs.push(output_claim); } if role == Role::Verifier { - value_exprs.extend( + scalar_exprs.extend( relation_output_values .iter() - .map(stage5_structured_polynomial_value_expr), + .map(stage5_structured_polynomial_scalar_expr), ); } @@ -735,7 +735,7 @@ impl Stage5CpuProgram { opening_inputs, field_constants, field_exprs, - value_exprs, + scalar_exprs, kernels, claims, batches, @@ -855,9 +855,9 @@ impl Stage5CpuProgram { } } } - for expr in &self.value_exprs { - super::plan_tokens::verify_value_expr_operands( - super::plan_tokens::ValueExprVerification { + for expr in &self.scalar_exprs { + super::plan_tokens::verify_scalar_expr_operands( + super::plan_tokens::ScalarExprVerification { stage: "stage5", symbol: &expr.symbol, formula: &expr.formula, @@ -932,8 +932,8 @@ impl Stage5CpuProgram { verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.value_exprs.iter().map(|expr| &expr.symbol), - verifier_values::VerifierScalarSourceKind::ValueExpr, + self.scalar_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ScalarExpr, ); values.extend( self.relation_outputs @@ -1549,8 +1549,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage5ClaimKind, FieldConstantPlan as Stage5FieldConstantPlan, FieldExprKind as Stage5FieldExprKind, FieldExprPlan as Stage5FieldExprPlan, - ValueExprKind as Stage5ValueExprKind, - ValueExprPlan as Stage5ValueExprPlan, + ScalarExprKind as Stage5ScalarExprKind, + ScalarExprPlan as Stage5ScalarExprPlan, KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan, OpeningClaimEqualityPlan as Stage5OpeningClaimEqualityPlan, OpeningClaimPlan as Stage5OpeningClaimPlan, OpeningInputPlan as Stage5OpeningInputPlan, @@ -1614,8 +1614,8 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } else { "" }; - let value_exprs_field = if self.role == Role::Verifier { - " value_exprs: STAGE5_VALUE_EXPRS,\n" + let scalar_exprs_field = if self.role == Role::Verifier { + " scalar_exprs: STAGE5_SCALAR_EXPRS,\n" } else { "" }; @@ -1631,7 +1631,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); \x20 opening_inputs: STAGE5_OPENING_INPUTS,\n\ \x20 field_constants: STAGE5_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE5_FIELD_EXPRS,\n\ - {value_exprs_field}\ + {scalar_exprs_field}\ \x20 kernels: STAGE5_KERNELS,\n\ \x20 claims: STAGE5_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE5_SUMCHECK_BATCHES,\n\ @@ -1670,7 +1670,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); if self.role == Role::Verifier { - source.push_str(&self.emit_value_expr_constants()?); + source.push_str(&self.emit_scalar_expr_constants()?); } Ok(source) } @@ -1860,12 +1860,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); Ok(source) } - fn emit_value_expr_constants(&self) -> Result { + fn emit_scalar_expr_constants(&self) -> Result { let plan = self.verifier_plan()?; - Ok(verifier_plan::emit_value_expr_constants( + Ok(verifier_plan::emit_scalar_expr_constants( "Stage5", "STAGE5", - &plan.value_exprs, + &plan.scalar_exprs, )) } @@ -2428,7 +2428,7 @@ where } })?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage5Error::from)?; artifacts.challenge_vectors.push(Stage5ChallengeVector { symbol: squeeze.symbol, @@ -2506,7 +2506,7 @@ where program.claims, program.batches, program.field_exprs, - program.value_exprs, + program.scalar_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -2563,7 +2563,7 @@ fn observe_stage5_sumcheck_output( }, )?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage5Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2614,7 +2614,7 @@ fn expected_batched_output_claim( bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, @@ -2628,7 +2628,7 @@ fn expected_batched_output_claim( bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 221d55b6dc..a3d169181c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -12,7 +12,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::rust_target_plan::{ - structured_polynomial_value_formula, FieldExprKind, ValueExprKind, + structured_polynomial_scalar_formula, FieldExprKind, ScalarExprKind, }; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, @@ -74,7 +74,7 @@ pub struct Stage6CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, - pub value_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -159,7 +159,7 @@ pub struct Stage6FieldExprPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6ValueExprPlan { +pub struct Stage6ScalarExprPlan { pub symbol: String, pub kind: String, pub formula: String, @@ -305,7 +305,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_input = Stage6OpeningInputPlan, field_constant = Stage6FieldConstantPlan, field_expr = Stage6FieldExprPlan, - value_expr = Stage6ValueExprPlan, + scalar_expr = Stage6ScalarExprPlan, claim = Stage6SumcheckClaimPlan, batch = Stage6SumcheckBatchPlan, driver = Stage6SumcheckDriverPlan, @@ -349,7 +349,7 @@ impl Stage6CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); - let mut value_exprs = Vec::new(); + let mut scalar_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -719,17 +719,17 @@ impl Stage6CpuProgram { let bytecode_output_plan = stage6_bytecode_read_raf_relation_output_plan(bytecode_ra_evals); for expr in bytecode_output_plan.field_exprs { - if ValueExprKind::from_cpu_attr(&expr.formula).is_ok() { - value_exprs.push(stage6_value_expr(expr)); + if ScalarExprKind::from_cpu_attr(&expr.formula).is_ok() { + scalar_exprs.push(stage6_scalar_expr(expr)); } else { field_exprs.push(stage6_relation_output_expr(expr)); } } relation_outputs.push(bytecode_output_plan.claim); - value_exprs.extend( + scalar_exprs.extend( relation_output_values .iter() - .map(stage6_structured_polynomial_value_expr), + .map(stage6_structured_polynomial_scalar_expr), ); } @@ -744,7 +744,7 @@ impl Stage6CpuProgram { opening_inputs, field_constants, field_exprs, - value_exprs, + scalar_exprs, kernels, claims, batches, @@ -865,9 +865,9 @@ impl Stage6CpuProgram { } } } - for expr in &self.value_exprs { - super::plan_tokens::verify_value_expr_operands( - super::plan_tokens::ValueExprVerification { + for expr in &self.scalar_exprs { + super::plan_tokens::verify_scalar_expr_operands( + super::plan_tokens::ScalarExprVerification { stage: "stage6", symbol: &expr.symbol, formula: &expr.formula, @@ -942,8 +942,8 @@ impl Stage6CpuProgram { verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.value_exprs.iter().map(|expr| &expr.symbol), - verifier_values::VerifierScalarSourceKind::ValueExpr, + self.scalar_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ScalarExpr, ); values.extend( self.relation_outputs @@ -1565,8 +1565,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage6ClaimKind, FieldConstantPlan as Stage6FieldConstantPlan, FieldExprKind as Stage6FieldExprKind, FieldExprPlan as Stage6FieldExprPlan, - ValueExprKind as Stage6ValueExprKind, - ValueExprPlan as Stage6ValueExprPlan, + ScalarExprKind as Stage6ScalarExprKind, + ScalarExprPlan as Stage6ScalarExprPlan, KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan, OpeningClaimEqualityPlan as Stage6OpeningClaimEqualityPlan, OpeningClaimPlan as Stage6OpeningClaimPlan, OpeningInputPlan as Stage6OpeningInputPlan, @@ -1693,8 +1693,8 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); } else { "" }; - let value_exprs_field = if self.role == Role::Verifier { - " value_exprs: STAGE6_VALUE_EXPRS,\n" + let scalar_exprs_field = if self.role == Role::Verifier { + " scalar_exprs: STAGE6_SCALAR_EXPRS,\n" } else { "" }; @@ -1710,7 +1710,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); \x20 opening_inputs: STAGE6_OPENING_INPUTS,\n\ \x20 field_constants: STAGE6_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE6_FIELD_EXPRS,\n\ - {value_exprs_field}\ + {scalar_exprs_field}\ \x20 kernels: STAGE6_KERNELS,\n\ \x20 claims: STAGE6_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE6_SUMCHECK_BATCHES,\n\ @@ -1750,7 +1750,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); if self.role == Role::Verifier { - source.push_str(&self.emit_value_expr_constants()?); + source.push_str(&self.emit_scalar_expr_constants()?); } Ok(source) } @@ -1942,13 +1942,13 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); Ok(source) } - fn emit_value_expr_constants(&self) -> Result { + fn emit_scalar_expr_constants(&self) -> Result { let plan = self.verifier_plan()?; - Ok(verifier_plan::emit_value_expr_constants_chunked( + Ok(verifier_plan::emit_scalar_expr_constants_chunked( "Stage6", "STAGE6", - "stage6_value_expr", - &plan.value_exprs, + "stage6_scalar_expr", + &plan.scalar_exprs, 16, )) } @@ -2554,7 +2554,7 @@ where } })?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage6Error::from)?; artifacts.challenge_vectors.push(Stage6ChallengeVector { symbol: squeeze.symbol, @@ -2634,7 +2634,7 @@ where program.claims, program.batches, program.field_exprs, - program.value_exprs, + program.scalar_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -2698,7 +2698,7 @@ fn observe_stage6_sumcheck_output( }, )?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage6Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2790,7 +2790,7 @@ fn expected_plan_relation_output( Ok(bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, @@ -2895,9 +2895,9 @@ fn stage6_relation_output_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage } } -fn stage6_value_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage6ValueExprPlan { +fn stage6_scalar_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage6ScalarExprPlan { let operands = expr.operands; - Stage6ValueExprPlan { + Stage6ScalarExprPlan { symbol: expr.symbol, kind: "op".to_owned(), formula: expr.formula, @@ -2906,14 +2906,14 @@ fn stage6_value_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage6ValueExpr } } -fn stage6_structured_polynomial_value_expr( +fn stage6_structured_polynomial_scalar_expr( value: &Stage6StructuredPolynomialEvalPlan, -) -> Stage6ValueExprPlan { +) -> Stage6ScalarExprPlan { let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; - Stage6ValueExprPlan { + Stage6ScalarExprPlan { symbol: value.symbol.clone(), kind: "op".to_owned(), - formula: structured_polynomial_value_formula( + formula: structured_polynomial_scalar_formula( value.polynomial.as_str(), value.x_point.segment.as_str(), value.x_point.length.as_str(), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index a7bd69bc99..61d41e5d71 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -12,7 +12,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::rust_target_plan::{ - power_strided_weighted_sum_formula, structured_polynomial_value_formula, ValueExprKind, + power_strided_weighted_sum_formula, structured_polynomial_scalar_formula, ScalarExprKind, }; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ @@ -54,7 +54,7 @@ pub struct Stage7CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, - pub value_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -139,7 +139,7 @@ pub struct Stage7FieldExprPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7ValueExprPlan { +pub struct Stage7ScalarExprPlan { pub symbol: String, pub kind: String, pub formula: String, @@ -167,8 +167,8 @@ fn stage7_relation_output_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage } } -fn stage7_value_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage7ValueExprPlan { - Stage7ValueExprPlan { +fn stage7_scalar_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage7ScalarExprPlan { + Stage7ScalarExprPlan { symbol: expr.symbol, kind: "op".to_owned(), formula: expr.formula, @@ -177,14 +177,14 @@ fn stage7_value_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage7ValueExpr } } -fn stage7_structured_polynomial_value_expr( +fn stage7_structured_polynomial_scalar_expr( value: &Stage7StructuredPolynomialEvalPlan, -) -> Stage7ValueExprPlan { +) -> Stage7ScalarExprPlan { let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; - Stage7ValueExprPlan { + Stage7ScalarExprPlan { symbol: value.symbol.clone(), kind: "op".to_owned(), - formula: structured_polynomial_value_formula( + formula: structured_polynomial_scalar_formula( value.polynomial.as_str(), value.x_point.segment.as_str(), value.x_point.length.as_str(), @@ -206,7 +206,7 @@ struct HammingWeightClaimRow { fn compact_hamming_weight_input_claim( field_exprs: &mut Vec, - value_exprs: &mut Vec, + scalar_exprs: &mut Vec, claims: &mut [Stage7SumcheckClaimPlan], opening_inputs: &[Stage7OpeningInputPlan], ) -> Result<(), EmitError> { @@ -240,7 +240,7 @@ fn compact_hamming_weight_input_claim( operands.extend(rows.iter().map(|row| row.virtualization.clone())); field_exprs.retain(|expr| !is_hamming_weight_input_claim_expr(&expr.symbol)); - value_exprs.push(Stage7ValueExprPlan { + scalar_exprs.push(Stage7ScalarExprPlan { symbol: compact_symbol.to_owned(), kind: "op".to_owned(), formula: power_strided_weighted_sum_formula(row_count, 3, &[], &[], &[0, 1, 2]), @@ -454,7 +454,7 @@ verifier_plan::impl_verifier_plan_source_traits!( opening_input = Stage7OpeningInputPlan, field_constant = Stage7FieldConstantPlan, field_expr = Stage7FieldExprPlan, - value_expr = Stage7ValueExprPlan, + scalar_expr = Stage7ScalarExprPlan, claim = Stage7SumcheckClaimPlan, batch = Stage7SumcheckBatchPlan, driver = Stage7SumcheckDriverPlan, @@ -497,7 +497,7 @@ impl Stage7CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); - let mut value_exprs = Vec::new(); + let mut scalar_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); @@ -827,7 +827,7 @@ impl Stage7CpuProgram { if is_verifier { compact_hamming_weight_input_claim( &mut field_exprs, - &mut value_exprs, + &mut scalar_exprs, &mut claims, &opening_inputs, )?; @@ -837,8 +837,8 @@ impl Stage7CpuProgram { &mut relation_output_eval_families, &mut relation_output_asts, )? { - if ValueExprKind::from_cpu_attr(&expr.formula).is_ok() { - value_exprs.push(stage7_value_expr(expr)); + if ScalarExprKind::from_cpu_attr(&expr.formula).is_ok() { + scalar_exprs.push(stage7_scalar_expr(expr)); } else { field_exprs.push(stage7_relation_output_expr(expr)); } @@ -867,10 +867,10 @@ impl Stage7CpuProgram { Vec::new() }; if role == Role::Verifier { - value_exprs.extend( + scalar_exprs.extend( relation_output_values .iter() - .map(stage7_structured_polynomial_value_expr), + .map(stage7_structured_polynomial_scalar_expr), ); } @@ -884,7 +884,7 @@ impl Stage7CpuProgram { opening_inputs, field_constants, field_exprs, - value_exprs, + scalar_exprs, kernels, claims, batches, @@ -998,9 +998,9 @@ impl Stage7CpuProgram { } } } - for expr in &self.value_exprs { - super::plan_tokens::verify_value_expr_operands( - super::plan_tokens::ValueExprVerification { + for expr in &self.scalar_exprs { + super::plan_tokens::verify_scalar_expr_operands( + super::plan_tokens::ScalarExprVerification { stage: "stage7", symbol: &expr.symbol, formula: &expr.formula, @@ -1045,8 +1045,8 @@ impl Stage7CpuProgram { verifier_values::VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.value_exprs.iter().map(|expr| &expr.symbol), - verifier_values::VerifierScalarSourceKind::ValueExpr, + self.scalar_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ScalarExpr, ); values.extend( self.evals.iter().map(|eval| &eval.symbol), @@ -1679,8 +1679,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage7ClaimKind, FieldConstantPlan as Stage7FieldConstantPlan, FieldExprKind as Stage7FieldExprKind, FieldExprPlan as Stage7FieldExprPlan, - ValueExprKind as Stage7ValueExprKind, - ValueExprPlan as Stage7ValueExprPlan, + ScalarExprKind as Stage7ScalarExprKind, + ScalarExprPlan as Stage7ScalarExprPlan, KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan, OpeningClaimEqualityPlan as Stage7OpeningClaimEqualityPlan, OpeningClaimPlan as Stage7OpeningClaimPlan, OpeningInputPlan as Stage7OpeningInputPlan, @@ -1744,8 +1744,8 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); } else { "" }; - let value_exprs_field = if self.role == Role::Verifier { - " value_exprs: STAGE7_VALUE_EXPRS,\n" + let scalar_exprs_field = if self.role == Role::Verifier { + " scalar_exprs: STAGE7_SCALAR_EXPRS,\n" } else { "" }; @@ -1761,7 +1761,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); \x20 opening_inputs: STAGE7_OPENING_INPUTS,\n\ \x20 field_constants: STAGE7_FIELD_CONSTANTS,\n\ \x20 field_exprs: STAGE7_FIELD_EXPRS,\n\ - {value_exprs_field}\ + {scalar_exprs_field}\ \x20 kernels: STAGE7_KERNELS,\n\ \x20 claims: STAGE7_SUMCHECK_CLAIMS,\n\ \x20 batches: STAGE7_SUMCHECK_BATCHES,\n\ @@ -1801,7 +1801,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); if self.role == Role::Verifier { - source.push_str(&self.emit_value_expr_constants()?); + source.push_str(&self.emit_scalar_expr_constants()?); } Ok(source) } @@ -1993,13 +1993,13 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); Ok(source) } - fn emit_value_expr_constants(&self) -> Result { + fn emit_scalar_expr_constants(&self) -> Result { let plan = self.verifier_plan()?; - Ok(verifier_plan::emit_value_expr_constants_chunked( + Ok(verifier_plan::emit_scalar_expr_constants_chunked( "Stage7", "STAGE7", - "stage7_value_expr", - &plan.value_exprs, + "stage7_scalar_expr", + &plan.scalar_exprs, 8, )) } @@ -2588,7 +2588,7 @@ where } })?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage7Error::from)?; artifacts.challenge_vectors.push(Stage7ChallengeVector { symbol: squeeze.symbol, @@ -2666,7 +2666,7 @@ where program.claims, program.batches, program.field_exprs, - program.value_exprs, + program.scalar_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -2719,7 +2719,7 @@ fn observe_stage7_sumcheck_output( }, )?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage7Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -2766,7 +2766,7 @@ fn expected_batched_output_claim( bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index 9517ee3017..c5e8ea90fe 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -266,7 +266,7 @@ pub(crate) enum FieldExprKind { } #[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) enum ValueExprKind { +pub(crate) enum ScalarExprKind { FieldVectorSum, FieldVectorProduct, StructuredPolynomial { @@ -355,19 +355,19 @@ impl FieldExprKind { } } -impl ValueExprKind { +impl ScalarExprKind { pub(crate) fn from_cpu_attr(value: &str) -> Result { match value { "field_vector.sum" => Ok(Self::FieldVectorSum), "field_vector.product" => Ok(Self::FieldVectorProduct), value if value.starts_with("poly.structured_eval:") => { - parse_structured_polynomial_value(value) + parse_structured_polynomial_scalar(value) } value if value.starts_with("field.power_strided_weighted_sum:") => { parse_power_strided_weighted_sum(value) } _ => Err(RustTargetPlanError::unsupported( - "value expression formula", + "scalar expression formula", value, )), } @@ -589,25 +589,25 @@ fn parse_lagrange(value: &str) -> Result { }) } -fn parse_power_strided_weighted_sum(value: &str) -> Result { +fn parse_power_strided_weighted_sum(value: &str) -> Result { let spec = value .strip_prefix("field.power_strided_weighted_sum:") - .ok_or_else(|| RustTargetPlanError::unsupported("field expression formula", value))?; + .ok_or_else(|| RustTargetPlanError::unsupported("scalar expression formula", value))?; let parts = spec.split(':').collect::>(); let [row_count, power_stride, value_offsets, shared_offsets, row_offsets] = parts.as_slice() else { return Err(RustTargetPlanError::unsupported( - "field expression formula", + "scalar expression formula", value, )); }; let row_count = row_count .parse::() - .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; + .map_err(|_| RustTargetPlanError::unsupported("scalar expression formula", value))?; let power_stride = power_stride .parse::() - .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; - Ok(ValueExprKind::PowerStridedWeightedSum { + .map_err(|_| RustTargetPlanError::unsupported("scalar expression formula", value))?; + Ok(ScalarExprKind::PowerStridedWeightedSum { row_count, power_stride, value_term_offsets: parse_usize_list(value_offsets, value)?, @@ -616,19 +616,19 @@ fn parse_power_strided_weighted_sum(value: &str) -> Result Result { +fn parse_structured_polynomial_scalar(value: &str) -> Result { let spec = value .strip_prefix("poly.structured_eval:") - .ok_or_else(|| RustTargetPlanError::unsupported("value expression formula", value))?; + .ok_or_else(|| RustTargetPlanError::unsupported("scalar expression formula", value))?; let [polynomial, x_segment, x_length, x_order, y_segment, y_length, y_order] = spec.split(':').collect::>()[..] else { return Err(RustTargetPlanError::unsupported( - "value expression formula", + "scalar expression formula", value, )); }; - Ok(ValueExprKind::StructuredPolynomial { + Ok(ScalarExprKind::StructuredPolynomial { polynomial: StructuredPolynomialKind::from_attr(polynomial)?, x_point: StructuredPolynomialPointTransform::new(x_segment, x_length, x_order)?, y_point: StructuredPolynomialPointTransform::new(y_segment, y_length, y_order)?, @@ -650,7 +650,7 @@ pub(crate) fn power_strided_weighted_sum_formula( ) } -pub(crate) fn structured_polynomial_value_formula( +pub(crate) fn structured_polynomial_scalar_formula( polynomial: &str, x_segment: &str, x_length: &str, @@ -672,7 +672,7 @@ fn parse_usize_list(value: &str, full_formula: &str) -> Result, RustT .split(',') .map(|part| { part.parse::().map_err(|_| { - RustTargetPlanError::unsupported("field expression formula", full_formula) + RustTargetPlanError::unsupported("scalar expression formula", full_formula) }) }) .collect() @@ -705,9 +705,9 @@ fn usize_slice_expr(values: &[usize]) -> String { mod tests { use super::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode, - ProgramStepKind, StructuredPolynomialKind, StructuredPolynomialPointLength, + ProgramStepKind, ScalarExprKind, StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointSegment, - StructuredPolynomialPointTransform, TranscriptSqueezeKind, ValueExprKind, + StructuredPolynomialPointTransform, TranscriptSqueezeKind, }; #[test] @@ -766,18 +766,18 @@ mod tests { } #[test] - fn parses_value_expr_kinds() { + fn parses_scalar_expr_kinds() { assert_eq!( - ValueExprKind::from_cpu_attr("field_vector.sum").ok(), - Some(ValueExprKind::FieldVectorSum) + ScalarExprKind::from_cpu_attr("field_vector.sum").ok(), + Some(ScalarExprKind::FieldVectorSum) ); assert_eq!( - ValueExprKind::from_cpu_attr("field_vector.product").ok(), - Some(ValueExprKind::FieldVectorProduct) + ScalarExprKind::from_cpu_attr("field_vector.product").ok(), + Some(ScalarExprKind::FieldVectorProduct) ); assert_eq!( - ValueExprKind::from_cpu_attr("field.power_strided_weighted_sum:39:3:0:1:2").ok(), - Some(ValueExprKind::PowerStridedWeightedSum { + ScalarExprKind::from_cpu_attr("field.power_strided_weighted_sum:39:3:0:1:2").ok(), + Some(ScalarExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: vec![0], @@ -786,11 +786,11 @@ mod tests { }) ); assert_eq!( - ValueExprKind::from_cpu_attr( + ScalarExprKind::from_cpu_attr( "poly.structured_eval:lt:suffix:y_point:reverse:full:full:as_is" ) .ok(), - Some(ValueExprKind::StructuredPolynomial { + Some(ScalarExprKind::StructuredPolynomial { polynomial: StructuredPolynomialKind::Lt, x_point: StructuredPolynomialPointTransform { segment: StructuredPolynomialPointSegment::Suffix, @@ -804,8 +804,8 @@ mod tests { }, }) ); - assert!(ValueExprKind::from_cpu_attr("field.power_strided_weighted_sum:1:2:0").is_err()); - assert!(ValueExprKind::from_cpu_attr("poly.structured_eval:eq:full").is_err()); + assert!(ScalarExprKind::from_cpu_attr("field.power_strided_weighted_sum:1:2:0").is_err()); + assert!(ScalarExprKind::from_cpu_attr("poly.structured_eval:eq:full").is_err()); } #[test] @@ -824,7 +824,7 @@ mod tests { "LagrangeBasisEval(-1, 3, 0)" ); assert_eq!( - ValueExprKind::PowerStridedWeightedSum { + ScalarExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: vec![0], @@ -835,7 +835,7 @@ mod tests { "PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }" ); assert_eq!( - ValueExprKind::StructuredPolynomial { + ScalarExprKind::StructuredPolynomial { polynomial: StructuredPolynomialKind::EqPlusOne, x_point: StructuredPolynomialPointTransform { segment: StructuredPolynomialPointSegment::Prefix, diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 0ad3a01766..7fd2c84791 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -4,7 +4,7 @@ use std::fmt::Write as _; use crate::emit::rust::EmitError; use crate::protocols::jolt::rust_target_plan::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, ProgramStepKind, - RustTargetPlanError, SumcheckPointOrder, TranscriptSqueezeKind, ValueExprKind, + RustTargetPlanError, ScalarExprKind, SumcheckPointOrder, TranscriptSqueezeKind, }; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_relation_outputs::{ @@ -134,13 +134,13 @@ impl VerifierFieldExprPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct VerifierValueExprPlan { +pub(crate) struct VerifierScalarExprPlan { pub(crate) symbol: String, - pub(crate) kind: ValueExprKind, + pub(crate) kind: ScalarExprKind, pub(crate) operands: Vec, } -impl VerifierValueExprPlan { +impl VerifierScalarExprPlan { pub(crate) fn from_cpu( symbol: &str, formula: &str, @@ -148,7 +148,7 @@ impl VerifierValueExprPlan { ) -> Result { Ok(Self { symbol: symbol.to_owned(), - kind: ValueExprKind::from_cpu_attr(formula).map_err(plan_error)?, + kind: ScalarExprKind::from_cpu_attr(formula).map_err(plan_error)?, operands: operands.to_vec(), }) } @@ -279,7 +279,7 @@ pub(crate) struct VerifierStagePlan { pub(crate) opening_inputs: Vec, pub(crate) field_constants: Vec, pub(crate) field_exprs: Vec, - pub(crate) value_exprs: Vec, + pub(crate) scalar_exprs: Vec, pub(crate) claims: Vec, pub(crate) batches: Vec, pub(crate) drivers: Vec, @@ -357,8 +357,8 @@ impl VerifierStagePlan { VerifierScalarSourceKind::FieldExpr, ); values.extend( - self.value_exprs.iter().map(|expr| &expr.symbol), - VerifierScalarSourceKind::ValueExpr, + self.scalar_exprs.iter().map(|expr| &expr.symbol), + VerifierScalarSourceKind::ScalarExpr, ); values.extend( self.relation_outputs @@ -471,7 +471,7 @@ pub(crate) trait VerifierFieldExprSource { fn operands(&self) -> &[String]; } -pub(crate) trait VerifierValueExprSource { +pub(crate) trait VerifierScalarExprSource { fn symbol(&self) -> &str; fn formula(&self) -> &str; fn operands(&self) -> &[String]; @@ -589,7 +589,7 @@ pub(crate) trait VerifierStagePlanSource { type OpeningInput: VerifierOpeningInputSource; type FieldConstant: VerifierFieldConstantSource; type FieldExpr: VerifierFieldExprSource; - type ValueExpr: VerifierValueExprSource; + type ScalarExpr: VerifierScalarExprSource; type Claim: VerifierSumcheckClaimSource; type Batch: VerifierSumcheckBatchSource; type Driver: VerifierSumcheckDriverSource; @@ -607,7 +607,7 @@ pub(crate) trait VerifierStagePlanSource { fn opening_inputs(&self) -> &[Self::OpeningInput]; fn field_constants(&self) -> &[Self::FieldConstant]; fn field_exprs(&self) -> &[Self::FieldExpr]; - fn value_exprs(&self) -> &[Self::ValueExpr]; + fn scalar_exprs(&self) -> &[Self::ScalarExpr]; fn claims(&self) -> &[Self::Claim]; fn batches(&self) -> &[Self::Batch]; fn drivers(&self) -> &[Self::Driver]; @@ -689,11 +689,11 @@ where VerifierFieldExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands()) }) .collect::, EmitError>>()?, - value_exprs: source - .value_exprs() + scalar_exprs: source + .scalar_exprs() .iter() .map(|expr| { - VerifierValueExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands()) + VerifierScalarExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands()) }) .collect::, EmitError>>()?, claims: source @@ -890,7 +890,7 @@ macro_rules! impl_verifier_plan_source_traits { opening_input = $opening_input:ty, field_constant = $field_constant:ty, field_expr = $field_expr:ty, - value_expr = $value_expr:ty, + scalar_expr = $scalar_expr:ty, claim = $claim:ty, batch = $batch:ty, driver = $driver:ty, @@ -915,7 +915,7 @@ macro_rules! impl_verifier_plan_source_traits { type OpeningInput = $opening_input; type FieldConstant = $field_constant; type FieldExpr = $field_expr; - type ValueExpr = $value_expr; + type ScalarExpr = $scalar_expr; type Claim = $claim; type Batch = $batch; type Driver = $driver; @@ -937,7 +937,7 @@ macro_rules! impl_verifier_plan_source_traits { fn opening_inputs(&self) -> &[Self::OpeningInput] { &self.opening_inputs } fn field_constants(&self) -> &[Self::FieldConstant] { &self.field_constants } fn field_exprs(&self) -> &[Self::FieldExpr] { &self.field_exprs } - fn value_exprs(&self) -> &[Self::ValueExpr] { &self.value_exprs } + fn scalar_exprs(&self) -> &[Self::ScalarExpr] { &self.scalar_exprs } fn claims(&self) -> &[Self::Claim] { &self.claims } fn batches(&self) -> &[Self::Batch] { &self.batches } fn drivers(&self) -> &[Self::Driver] { &self.drivers } @@ -1023,7 +1023,7 @@ macro_rules! impl_verifier_plan_source_traits { fn operands(&self) -> &[String] { &self.operands } } - impl $crate::protocols::jolt::verifier_plan::VerifierValueExprSource for $value_expr { + impl $crate::protocols::jolt::verifier_plan::VerifierScalarExprSource for $scalar_expr { fn symbol(&self) -> &str { &self.symbol } fn formula(&self) -> &str { &self.formula } fn operands(&self) -> &[String] { &self.operands } @@ -1245,9 +1245,9 @@ pub(crate) fn field_expr_kind_expr(stage_type_prefix: &str, kind: &FieldExprKind ) } -pub(crate) fn value_expr_kind_expr(stage_type_prefix: &str, kind: &ValueExprKind) -> String { +pub(crate) fn scalar_expr_kind_expr(stage_type_prefix: &str, kind: &ScalarExprKind) -> String { format!( - "{stage_type_prefix}ValueExprKind::{}", + "{stage_type_prefix}ScalarExprKind::{}", kind.rust_variant_expr() ) } @@ -1383,25 +1383,25 @@ pub(crate) fn emit_field_expr_constants( ) } -pub(crate) fn emit_value_expr_constants( +pub(crate) fn emit_scalar_expr_constants( stage_type_prefix: &str, const_prefix: &str, - exprs: &[VerifierValueExprPlan], + exprs: &[VerifierScalarExprPlan], ) -> String { let exprs = exprs .iter() .map(|expr| { format!( - " {stage_type_prefix}ValueExprPlan {{ symbol: {}, kind: {}, operands: {} }},", + " {stage_type_prefix}ScalarExprPlan {{ symbol: {}, kind: {}, operands: {} }},", rust_str(&expr.symbol), - value_expr_kind_expr(stage_type_prefix, &expr.kind), + scalar_expr_kind_expr(stage_type_prefix, &expr.kind), rust_str_slice_expr(&expr.operands), ) }) .collect::>() .join("\n"); format!( - "pub const {const_prefix}_VALUE_EXPRS: &[{stage_type_prefix}ValueExprPlan] = &[\n{exprs}\n];\n" + "pub const {const_prefix}_SCALAR_EXPRS: &[{stage_type_prefix}ScalarExprPlan] = &[\n{exprs}\n];\n" ) } @@ -1436,11 +1436,11 @@ pub(crate) fn emit_field_expr_constants_chunked( ) } -pub(crate) fn emit_value_expr_constants_chunked( +pub(crate) fn emit_scalar_expr_constants_chunked( stage_type_prefix: &str, const_prefix: &str, helper_name: &str, - exprs: &[VerifierValueExprPlan], + exprs: &[VerifierScalarExprPlan], chunk_size: usize, ) -> String { let rows = exprs @@ -1452,7 +1452,7 @@ pub(crate) fn emit_value_expr_constants_chunked( format!( "{helper_name}({}, {}, {})", rust_str(&expr.symbol), - value_expr_kind_expr(stage_type_prefix, &expr.kind), + scalar_expr_kind_expr(stage_type_prefix, &expr.kind), rust_str_slice_expr(&expr.operands) ) }) @@ -1463,7 +1463,7 @@ pub(crate) fn emit_value_expr_constants_chunked( .collect::>() .join("\n"); format!( - "const fn {helper_name}(symbol: &'static str, kind: {stage_type_prefix}ValueExprKind, operands: &'static [&'static str]) -> {stage_type_prefix}ValueExprPlan {{\n {stage_type_prefix}ValueExprPlan {{ symbol, kind, operands }}\n}}\n\n#[rustfmt::skip]\npub const {const_prefix}_VALUE_EXPRS: &[{stage_type_prefix}ValueExprPlan] = &[\n{rows}\n];\n" + "const fn {helper_name}(symbol: &'static str, kind: {stage_type_prefix}ScalarExprKind, operands: &'static [&'static str]) -> {stage_type_prefix}ScalarExprPlan {{\n {stage_type_prefix}ScalarExprPlan {{ symbol, kind, operands }}\n}}\n\n#[rustfmt::skip]\npub const {const_prefix}_SCALAR_EXPRS: &[{stage_type_prefix}ScalarExprPlan] = &[\n{rows}\n];\n" ) } diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 865dc52b75..024876f19d 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -8,7 +8,7 @@ pub enum VerifierScalarSourceKind { FieldConstant, TranscriptScalar, FieldExpr, - ValueExpr, + ScalarExpr, PointDerived, SumcheckEval, OutputEvalFamily, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 55cbaca4fb..cd10c1f3fa 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -2083,20 +2083,20 @@ fn stage7_rust_targets_extract_and_compile() { "stage7.hamming_weight_claim_reduction.input.claim_expr" ); let input_expr = verifier_program - .value_exprs + .scalar_exprs .iter() .find(|expr| expr.symbol == "stage7.hamming_weight_claim_reduction.input.claim_expr") - .expect("stage7 hamming input claim is lowered to a value expression"); + .expect("stage7 hamming input claim is lowered to a scalar expression"); assert_eq!( input_expr.formula, format!("field.power_strided_weighted_sum:{total_ra}:3:_:_:0,1,2") ); assert_eq!(input_expr.operands.len(), 1 + total_ra + 3 * total_ra); let output_expr = verifier_program - .value_exprs + .scalar_exprs .iter() .find(|expr| expr.symbol == "stage7.hamming_weight_claim_reduction.output.claim_expr") - .expect("stage7 hamming output is lowered to a value expression"); + .expect("stage7 hamming output is lowered to a scalar expression"); assert_eq!( output_expr.formula, format!("field.power_strided_weighted_sum:{total_ra}:3:0:1:2") @@ -2167,7 +2167,7 @@ fn stage7_rust_targets_extract_and_compile() { .contains("STAGE7_RELATION_OUTPUT_0_FAMILY_0_EVALS")); assert!(verifier_source .source - .contains("Stage7ValueExprKind::PowerStridedWeightedSum")); + .contains("Stage7ScalarExprKind::PowerStridedWeightedSum")); assert!(!verifier_source .source .contains("Stage7FieldExprKind::PowerStridedWeightedSum")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index f7fbbb46c0..8fb1a20821 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -23,11 +23,11 @@ macro_rules! stage_field_expr { }; } -macro_rules! stage_value_expr { - (generated, $module:ident, $value_expr:ident, $plan:ident) => { - $module::$value_expr { +macro_rules! stage_scalar_expr { + (generated, $module:ident, $scalar_expr:ident, $plan:ident) => { + $module::$scalar_expr { symbol: super::leak_str(&$plan.symbol), - kind: super::generated_value_expr_kind($plan.formula.as_str()), + kind: super::generated_scalar_expr_kind($plan.formula.as_str()), operands: super::leak_str_slice(&$plan.operands), } }; @@ -312,12 +312,12 @@ fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKin #[expect( clippy::expect_used, clippy::panic, - reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier value expression tag" + reason = "equivalence adapters fail fast when a compiler plan contains an unsupported generated verifier scalar expression tag" )] -fn generated_value_expr_kind(value: &str) -> bolt_verifier_runtime::ValueExprKind { +fn generated_scalar_expr_kind(value: &str) -> bolt_verifier_runtime::ScalarExprKind { match value { - "field_vector.sum" => bolt_verifier_runtime::ValueExprKind::FieldVectorSum, - "field_vector.product" => bolt_verifier_runtime::ValueExprKind::FieldVectorProduct, + "field_vector.sum" => bolt_verifier_runtime::ScalarExprKind::FieldVectorSum, + "field_vector.product" => bolt_verifier_runtime::ScalarExprKind::FieldVectorProduct, value if value.starts_with("field.power_strided_weighted_sum:") => { let spec = value .strip_prefix("field.power_strided_weighted_sum:") @@ -327,7 +327,7 @@ fn generated_value_expr_kind(value: &str) -> bolt_verifier_runtime::ValueExprKin parts.len() == 5, "power-strided weighted expression has five fields" ); - bolt_verifier_runtime::ValueExprKind::PowerStridedWeightedSum { + bolt_verifier_runtime::ScalarExprKind::PowerStridedWeightedSum { row_count: parts[0] .parse::() .expect("power-strided weighted row count is usize"), @@ -348,7 +348,7 @@ fn generated_value_expr_kind(value: &str) -> bolt_verifier_runtime::ValueExprKin parts.len() == 7, "structured polynomial expression has seven fields" ); - bolt_verifier_runtime::ValueExprKind::StructuredPolynomial { + bolt_verifier_runtime::ScalarExprKind::StructuredPolynomial { polynomial: generated_structured_polynomial_kind(parts[0]), x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: generated_structured_polynomial_point_segment(parts[1]), @@ -362,7 +362,7 @@ fn generated_value_expr_kind(value: &str) -> bolt_verifier_runtime::ValueExprKin }, } } - value => panic!("unsupported generated value expression kind `{value}`"), + value => panic!("unsupported generated scalar expression kind `{value}`"), } } @@ -541,8 +541,8 @@ macro_rules! define_stage_adapter_impl { $(, role = $role_field:ident)? $(, transcript_absorb_bytes = $absorb:ident)? $(, kernels = $kernel:ident)? - $(, value_expr = $value_expr:ident)? - $(, empty_value_exprs = $empty_value_exprs:ident)? + $(, scalar_expr = $scalar_expr:ident)? + $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? $(, point_zeros = $point_zero:ident)? $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? @@ -627,17 +627,17 @@ macro_rules! define_stage_adapter_impl { .collect(), ), $( - value_exprs: super::leak_slice( + scalar_exprs: super::leak_slice( program - .value_exprs + .scalar_exprs .iter() - .map(|plan| stage_value_expr!($mode, $module, $value_expr, plan)) + .map(|plan| stage_scalar_expr!($mode, $module, $scalar_expr, plan)) .collect(), ), )? $( - value_exprs: { - let _ = stringify!($empty_value_exprs); + scalar_exprs: { + let _ = stringify!($empty_scalar_exprs); &[] }, )? @@ -875,8 +875,8 @@ macro_rules! define_stage_adapter { $opening_equality:ident, $opening_batch:ident $(, point_zero = $point_zero:ident)? - $(, value_expr = $value_expr:ident)? - $(, empty_value_exprs = $empty_value_exprs:ident)? + $(, scalar_expr = $scalar_expr:ident)? + $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? ) => { @@ -904,8 +904,8 @@ macro_rules! define_stage_adapter { role = role, transcript_absorb_bytes = $absorb, kernels = $kernel - $(, value_expr = $value_expr)? - $(, empty_value_exprs = $empty_value_exprs)? + $(, scalar_expr = $scalar_expr)? + $(, empty_scalar_exprs = $empty_scalar_exprs)? $(, point_zeros = $point_zero)? $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? $(, empty_relation_outputs = $empty_relation_outputs)? @@ -938,8 +938,8 @@ macro_rules! define_stage_adapter_no_absorb { $opening_claim:ident, $opening_batch:ident $(, kernels = $kernel:ident)? - $(, value_expr = $value_expr:ident)? - $(, empty_value_exprs = $empty_value_exprs:ident)? + $(, scalar_expr = $scalar_expr:ident)? + $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? @@ -966,8 +966,8 @@ macro_rules! define_stage_adapter_no_absorb { $opening_claim, $opening_batch $(, kernels = $kernel)? - $(, value_expr = $value_expr)? - $(, empty_value_exprs = $empty_value_exprs)? + $(, scalar_expr = $scalar_expr)? + $(, empty_scalar_exprs = $empty_scalar_exprs)? $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? $(, empty_relation_outputs = $empty_relation_outputs)? $(, opening_equalities = $opening_equality)? diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs index 6a449b9766..fe3d348673 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs @@ -22,5 +22,5 @@ define_stage_adapter_no_absorb!( Stage2PointConcatPlan, Stage2OpeningClaimPlan, Stage2OpeningBatchPlan, - empty_value_exprs = Stage2ValueExprPlan + empty_scalar_exprs = Stage2ScalarExprPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs index 81436a8b72..f72f28d4bb 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs @@ -22,7 +22,7 @@ define_stage_adapter_no_absorb!( Stage3PointConcatPlan, Stage3OpeningClaimPlan, Stage3OpeningBatchPlan, - value_expr = Stage3ValueExprPlan, + scalar_expr = Stage3ScalarExprPlan, relation_outputs = Stage3RelationOutputPlan, relation_output_values = Stage3StructuredPolynomialEvalPlan, opening_equalities = Stage3OpeningClaimEqualityPlan diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs index 1b3cb4cad0..8d4328b1b4 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs @@ -25,7 +25,7 @@ define_stage_adapter!( Stage4OpeningClaimPlan, Stage4OpeningClaimEqualityPlan, Stage4OpeningBatchPlan, - value_expr = Stage4ValueExprPlan, + scalar_expr = Stage4ScalarExprPlan, relation_outputs = Stage4RelationOutputPlan, relation_output_values = Stage4StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs index f026b3ca15..fa7f0b6877 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs @@ -25,7 +25,7 @@ define_stage_adapter!( Stage5OpeningClaimPlan, Stage5OpeningClaimEqualityPlan, Stage5OpeningBatchPlan, - value_expr = Stage5ValueExprPlan, + scalar_expr = Stage5ScalarExprPlan, relation_outputs = Stage5RelationOutputPlan, relation_output_values = Stage5StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs index aad92a4e51..e33b720390 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs @@ -26,7 +26,7 @@ define_stage_adapter!( Stage6OpeningClaimEqualityPlan, Stage6OpeningBatchPlan, point_zero = Stage6PointZeroPlan, - value_expr = Stage6ValueExprPlan, + scalar_expr = Stage6ScalarExprPlan, relation_outputs = Stage6RelationOutputPlan, relation_output_values = Stage6StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs index 78f377d3fa..e4569b630d 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs @@ -26,7 +26,7 @@ define_stage_adapter!( Stage7OpeningClaimEqualityPlan, Stage7OpeningBatchPlan, point_zero = Stage7PointZeroPlan, - value_expr = Stage7ValueExprPlan, + scalar_expr = Stage7ScalarExprPlan, relation_outputs = Stage7RelationOutputPlan, relation_output_values = Stage7StructuredPolynomialEvalPlan ); diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index eb8ea2d9c1..a90bd21389 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -25,7 +25,7 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage2ClaimKind, FieldConstantPlan as Stage2FieldConstantPlan, FieldExprKind as Stage2FieldExprKind, FieldExprPlan as Stage2FieldExprPlan, - ValueExprPlan as Stage2ValueExprPlan, + ScalarExprPlan as Stage2ScalarExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, OpeningInputPlan as Stage2OpeningInputPlan, PointConcatPlan as Stage2PointConcatPlan, PointSlicePlan as Stage2PointSlicePlan, ProgramStepKind as Stage2ProgramStepKind, @@ -145,7 +145,7 @@ pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LeftInstructionInput", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.RightOperand", "stage2.instruction_lookup.term.LeftInstructionInput"] }, Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.LeftInstructionInput", "stage2.instruction_lookup.term.RightInstructionInput"] }, ]; -pub const STAGE2_VALUE_EXPRS: &[Stage2ValueExprPlan] = &[]; +pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[]; pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[ Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr" }, Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some(Stage2RelationKind::Stage2RamReadWrite), claim_value: "stage2.ram_read_write.claim_expr" }, @@ -248,7 +248,7 @@ pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan opening_inputs: STAGE2_OPENING_INPUTS, field_constants: STAGE2_FIELD_CONSTANTS, field_exprs: STAGE2_FIELD_EXPRS, - value_exprs: STAGE2_VALUE_EXPRS, + scalar_exprs: STAGE2_SCALAR_EXPRS, claims: STAGE2_SUMCHECK_CLAIMS, batches: STAGE2_SUMCHECK_BATCHES, drivers: STAGE2_SUMCHECK_DRIVERS, @@ -641,7 +641,7 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, ) -> Result<(), VerifyStage2Error> { self.0 - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage2Error::from) } diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index fcf40b9362..baaedb771e 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -25,8 +25,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage3ClaimKind, FieldConstantPlan as Stage3FieldConstantPlan, FieldExprKind as Stage3FieldExprKind, FieldExprPlan as Stage3FieldExprPlan, - ValueExprKind as Stage3ValueExprKind, - ValueExprPlan as Stage3ValueExprPlan, + ScalarExprKind as Stage3ScalarExprKind, + ScalarExprPlan as Stage3ScalarExprPlan, OpeningBatchPlan as Stage3OpeningBatchPlan, OpeningClaimEqualityPlan as Stage3OpeningClaimEqualityPlan, OpeningClaimPlan as Stage3OpeningClaimPlan, OpeningInputPlan as Stage3OpeningInputPlan, @@ -138,11 +138,11 @@ pub const STAGE3_FIELD_EXPRS: &[Stage3FieldExprPlan] = &[ Stage3FieldExprPlan { symbol: "stage3.registers.output.weighted_register_values", kind: Stage3FieldExprKind::Add, operands: &["stage3.registers.output.partial.RdWriteValueRs1Value", "stage3.registers.output.term.Rs2Value"] }, Stage3FieldExprPlan { symbol: "stage3.registers.output.claim_expr", kind: Stage3FieldExprKind::Mul, operands: &["stage3.registers.output.eq.RdWriteValue", "stage3.registers.output.weighted_register_values"] }, ]; -pub const STAGE3_VALUE_EXPRS: &[Stage3ValueExprPlan] = &[ - Stage3ValueExprPlan { symbol: "stage3.spartan_shift.output.eq.NextPC", kind: Stage3ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.spartan_shift.instance", "stage3.input.stage1.NextPC"] }, - Stage3ValueExprPlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", kind: Stage3ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.spartan_shift.instance", "stage3.input.stage2.product_virtual.NextIsNoop"] }, - Stage3ValueExprPlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", kind: Stage3ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.instruction_input.instance", "stage3.input.stage2.product_virtual.LeftInstructionInput"] }, - Stage3ValueExprPlan { symbol: "stage3.registers.output.eq.RdWriteValue", kind: Stage3ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.registers_claim_reduction.instance", "stage3.input.stage1.RdWriteValue"] }, +pub const STAGE3_SCALAR_EXPRS: &[Stage3ScalarExprPlan] = &[ + Stage3ScalarExprPlan { symbol: "stage3.spartan_shift.output.eq.NextPC", kind: Stage3ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.spartan_shift.instance", "stage3.input.stage1.NextPC"] }, + Stage3ScalarExprPlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", kind: Stage3ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.spartan_shift.instance", "stage3.input.stage2.product_virtual.NextIsNoop"] }, + Stage3ScalarExprPlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", kind: Stage3ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.instruction_input.instance", "stage3.input.stage2.product_virtual.LeftInstructionInput"] }, + Stage3ScalarExprPlan { symbol: "stage3.registers.output.eq.RdWriteValue", kind: Stage3ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage3.registers_claim_reduction.instance", "stage3.input.stage1.RdWriteValue"] }, ]; pub const STAGE3_SUMCHECK_CLAIMS: &[Stage3SumcheckClaimPlan] = &[ Stage3SumcheckClaimPlan { symbol: "stage3.spartan_shift.input", stage: "stage3", domain: "jolt.trace_domain", num_rounds: 16, degree: 2, claim: "stage3.spartan_shift.weighted_next_values", kernel: None, relation: Some(Stage3RelationKind::Stage3SpartanShift), claim_value: "stage3.spartan_shift.claim_expr" }, @@ -238,7 +238,7 @@ pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan opening_inputs: STAGE3_OPENING_INPUTS, field_constants: STAGE3_FIELD_CONSTANTS, field_exprs: STAGE3_FIELD_EXPRS, - value_exprs: STAGE3_VALUE_EXPRS, + scalar_exprs: STAGE3_SCALAR_EXPRS, claims: STAGE3_SUMCHECK_CLAIMS, batches: STAGE3_SUMCHECK_BATCHES, drivers: STAGE3_SUMCHECK_DRIVERS, @@ -336,7 +336,7 @@ where } })?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage3Error::from)?; artifacts.challenge_vectors.push(Stage3ChallengeVector { symbol: squeeze.symbol, @@ -403,7 +403,7 @@ where program.claims, program.batches, program.field_exprs, - program.value_exprs, + program.scalar_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -456,7 +456,7 @@ fn observe_stage3_sumcheck_output( }, )?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage3Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -495,7 +495,7 @@ fn expected_batched_output_claim( let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 45d42c1ff3..7ba1940bbf 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -23,8 +23,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage4ClaimKind, FieldConstantPlan as Stage4FieldConstantPlan, FieldExprKind as Stage4FieldExprKind, FieldExprPlan as Stage4FieldExprPlan, - ValueExprKind as Stage4ValueExprKind, - ValueExprPlan as Stage4ValueExprPlan, + ScalarExprKind as Stage4ScalarExprKind, + ScalarExprPlan as Stage4ScalarExprPlan, KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan, OpeningClaimEqualityPlan as Stage4OpeningClaimEqualityPlan, OpeningClaimPlan as Stage4OpeningClaimPlan, OpeningInputPlan as Stage4OpeningInputPlan, @@ -117,9 +117,9 @@ pub const STAGE4_FIELD_EXPRS: &[Stage4FieldExprPlan] = &[ Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.term.RamIncRamRa", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.eval.RamInc", "stage4.ram_val_check.eval.RamRa"] }, Stage4FieldExprPlan { symbol: "stage4.ram_val_check.output.claim_expr", kind: Stage4FieldExprKind::Mul, operands: &["stage4.ram_val_check.output.term.RamIncRamRa", "stage4.ram_val_check.output.lt_plus_gamma"] }, ]; -pub const STAGE4_VALUE_EXPRS: &[Stage4ValueExprPlan] = &[ - Stage4ValueExprPlan { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", kind: Stage4ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage4.registers_read_write.instance", "stage4.input.stage3.registers.RdWriteValue"] }, - Stage4ValueExprPlan { symbol: "stage4.ram_val_check.output.lt.RamValCycle", kind: Stage4ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Lt, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage4.ram_val_check.instance", "stage4.input.stage2.RamVal"] }, +pub const STAGE4_SCALAR_EXPRS: &[Stage4ScalarExprPlan] = &[ + Stage4ScalarExprPlan { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", kind: Stage4ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage4.registers_read_write.instance", "stage4.input.stage3.registers.RdWriteValue"] }, + Stage4ScalarExprPlan { symbol: "stage4.ram_val_check.output.lt.RamValCycle", kind: Stage4ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Lt, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage4.ram_val_check.instance", "stage4.input.stage2.RamVal"] }, ]; pub const STAGE4_KERNELS: &[Stage4KernelPlan] = &[ @@ -199,7 +199,7 @@ pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { opening_inputs: STAGE4_OPENING_INPUTS, field_constants: STAGE4_FIELD_CONSTANTS, field_exprs: STAGE4_FIELD_EXPRS, - value_exprs: STAGE4_VALUE_EXPRS, + scalar_exprs: STAGE4_SCALAR_EXPRS, kernels: STAGE4_KERNELS, claims: STAGE4_SUMCHECK_CLAIMS, batches: STAGE4_SUMCHECK_BATCHES, @@ -300,7 +300,7 @@ where } })?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage4Error::from)?; artifacts.challenge_vectors.push(Stage4ChallengeVector { symbol: squeeze.symbol, @@ -378,7 +378,7 @@ where program.claims, program.batches, program.field_exprs, - program.value_exprs, + program.scalar_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -434,7 +434,7 @@ fn observe_stage4_sumcheck_output( }, )?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage4Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -473,7 +473,7 @@ fn expected_batched_output_claim( let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index c25b7b9b9d..63e5c1188a 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -24,8 +24,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage5ClaimKind, FieldConstantPlan as Stage5FieldConstantPlan, FieldExprKind as Stage5FieldExprKind, FieldExprPlan as Stage5FieldExprPlan, - ValueExprKind as Stage5ValueExprKind, - ValueExprPlan as Stage5ValueExprPlan, + ScalarExprKind as Stage5ScalarExprKind, + ScalarExprPlan as Stage5ScalarExprPlan, KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan, OpeningClaimEqualityPlan as Stage5OpeningClaimEqualityPlan, OpeningClaimPlan as Stage5OpeningClaimPlan, OpeningInputPlan as Stage5OpeningInputPlan, @@ -166,13 +166,13 @@ pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[ Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.EqRa", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.output.eq.LookupOutputCycle", "stage5.instruction_read_raf.output.product.InstructionRa"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.output.partial.EqRa", "stage5.instruction_read_raf.output.partial.LookupOrRaf"] }, ]; -pub const STAGE5_VALUE_EXPRS: &[Stage5ValueExprPlan] = &[ - Stage5ValueExprPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", kind: Stage5ValueExprKind::FieldVectorProduct, operands: &["stage5.instruction_read_raf.eval.InstructionRa"] }, - Stage5ValueExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", kind: Stage5ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage2.ram_raf.RamRa"] }, - Stage5ValueExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", kind: Stage5ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage2.ram_read_write.RamRa"] }, - Stage5ValueExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", kind: Stage5ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage4.ram_val_check.RamRa"] }, - Stage5ValueExprPlan { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", kind: Stage5ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Lt, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.registers_val_evaluation.instance", "stage5.input.stage4.registers.RegistersVal"] }, - Stage5ValueExprPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", kind: Stage5ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.instruction_read_raf.instance", "stage5.input.stage2.instruction.LookupOutput"] }, +pub const STAGE5_SCALAR_EXPRS: &[Stage5ScalarExprPlan] = &[ + Stage5ScalarExprPlan { symbol: "stage5.instruction_read_raf.output.product.InstructionRa", kind: Stage5ScalarExprKind::FieldVectorProduct, operands: &["stage5.instruction_read_raf.eval.InstructionRa"] }, + Stage5ScalarExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", kind: Stage5ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage2.ram_raf.RamRa"] }, + Stage5ScalarExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", kind: Stage5ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage2.ram_read_write.RamRa"] }, + Stage5ScalarExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", kind: Stage5ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.ram_ra_claim_reduction.instance", "stage5.input.stage4.ram_val_check.RamRa"] }, + Stage5ScalarExprPlan { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", kind: Stage5ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Lt, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.registers_val_evaluation.instance", "stage5.input.stage4.registers.RegistersVal"] }, + Stage5ScalarExprPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", kind: Stage5ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage5.instruction_read_raf.instance", "stage5.input.stage2.instruction.LookupOutput"] }, ]; pub const STAGE5_KERNELS: &[Stage5KernelPlan] = &[ @@ -435,7 +435,7 @@ pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { opening_inputs: STAGE5_OPENING_INPUTS, field_constants: STAGE5_FIELD_CONSTANTS, field_exprs: STAGE5_FIELD_EXPRS, - value_exprs: STAGE5_VALUE_EXPRS, + scalar_exprs: STAGE5_SCALAR_EXPRS, kernels: STAGE5_KERNELS, claims: STAGE5_SUMCHECK_CLAIMS, batches: STAGE5_SUMCHECK_BATCHES, @@ -536,7 +536,7 @@ where } })?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage5Error::from)?; artifacts.challenge_vectors.push(Stage5ChallengeVector { symbol: squeeze.symbol, @@ -614,7 +614,7 @@ where program.claims, program.batches, program.field_exprs, - program.value_exprs, + program.scalar_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -671,7 +671,7 @@ fn observe_stage5_sumcheck_output( }, )?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage5Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -722,7 +722,7 @@ fn expected_batched_output_claim( bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, @@ -736,7 +736,7 @@ fn expected_batched_output_claim( bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, &[], &[], local_point, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 8cf4c2a285..d0b6940719 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -24,8 +24,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage6ClaimKind, FieldConstantPlan as Stage6FieldConstantPlan, FieldExprKind as Stage6FieldExprKind, FieldExprPlan as Stage6FieldExprPlan, - ValueExprKind as Stage6ValueExprKind, - ValueExprPlan as Stage6ValueExprPlan, + ScalarExprKind as Stage6ScalarExprKind, + ScalarExprPlan as Stage6ScalarExprPlan, KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan, OpeningClaimEqualityPlan as Stage6OpeningClaimEqualityPlan, OpeningClaimPlan as Stage6OpeningClaimPlan, OpeningInputPlan as Stage6OpeningInputPlan, @@ -321,13 +321,13 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.instruction_ra_virtual.output.term2", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_2", "stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term3", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term4", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term5", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), stage6_field_expr("stage6.bytecode_read_raf.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.output.product.BytecodeRa"]), ]; -const fn stage6_value_expr(symbol: &'static str, kind: Stage6ValueExprKind, operands: &'static [&'static str]) -> Stage6ValueExprPlan { - Stage6ValueExprPlan { symbol, kind, operands } +const fn stage6_scalar_expr(symbol: &'static str, kind: Stage6ScalarExprKind, operands: &'static [&'static str]) -> Stage6ScalarExprPlan { + Stage6ScalarExprPlan { symbol, kind, operands } } #[rustfmt::skip] -pub const STAGE6_VALUE_EXPRS: &[Stage6ValueExprPlan] = &[ - stage6_value_expr("stage6.bytecode_read_raf.output.product.BytecodeRa", Stage6ValueExprKind::FieldVectorProduct, &["stage6.bytecode_read_raf.eval.BytecodeRa"]), stage6_value_expr("stage6.booleanity.output.eq.InstructionRa0", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.booleanity.instance", "stage6.booleanity.output.point"]), stage6_value_expr("stage6.hamming_booleanity.output.eq.LookupOutput", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse } }, &["stage6.hamming_booleanity.instance", "stage6.input.stage1.LookupOutput"]), stage6_value_expr("stage6.ram_ra_virtual.output.eq.Cycle", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.ram_ra_virtual.instance", "stage6.input.stage5.ram_ra_claim_reduction.RamRa"]), stage6_value_expr("stage6.instruction_ra_virtual.output.eq.Cycle", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.instruction_ra_virtual.instance", "stage6.input.stage5.instruction_read_raf.InstructionRa_0"]), stage6_value_expr("stage6.inc_claim_reduction.output.eq.RamIncStage2", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage2.ram_read_write.RamInc"]), stage6_value_expr("stage6.inc_claim_reduction.output.eq.RamIncStage4", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_value_expr("stage6.inc_claim_reduction.output.eq.RdIncStage4", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_value_expr("stage6.inc_claim_reduction.output.eq.RdIncStage5", Stage6ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage5.registers_val_evaluation.RdInc"]), +pub const STAGE6_SCALAR_EXPRS: &[Stage6ScalarExprPlan] = &[ + stage6_scalar_expr("stage6.bytecode_read_raf.output.product.BytecodeRa", Stage6ScalarExprKind::FieldVectorProduct, &["stage6.bytecode_read_raf.eval.BytecodeRa"]), stage6_scalar_expr("stage6.booleanity.output.eq.InstructionRa0", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.booleanity.instance", "stage6.booleanity.output.point"]), stage6_scalar_expr("stage6.hamming_booleanity.output.eq.LookupOutput", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse } }, &["stage6.hamming_booleanity.instance", "stage6.input.stage1.LookupOutput"]), stage6_scalar_expr("stage6.ram_ra_virtual.output.eq.Cycle", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.ram_ra_virtual.instance", "stage6.input.stage5.ram_ra_claim_reduction.RamRa"]), stage6_scalar_expr("stage6.instruction_ra_virtual.output.eq.Cycle", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.instruction_ra_virtual.instance", "stage6.input.stage5.instruction_read_raf.InstructionRa_0"]), stage6_scalar_expr("stage6.inc_claim_reduction.output.eq.RamIncStage2", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage2.ram_read_write.RamInc"]), stage6_scalar_expr("stage6.inc_claim_reduction.output.eq.RamIncStage4", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage4.ram_val_check.RamInc"]), stage6_scalar_expr("stage6.inc_claim_reduction.output.eq.RdIncStage4", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage4.registers_read_write.RdInc"]), stage6_scalar_expr("stage6.inc_claim_reduction.output.eq.RdIncStage5", Stage6ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Suffix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage6.inc_claim_reduction.instance", "stage6.input.stage5.registers_val_evaluation.RdInc"]), ]; pub const STAGE6_KERNELS: &[Stage6KernelPlan] = &[ @@ -696,7 +696,7 @@ pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { opening_inputs: STAGE6_OPENING_INPUTS, field_constants: STAGE6_FIELD_CONSTANTS, field_exprs: STAGE6_FIELD_EXPRS, - value_exprs: STAGE6_VALUE_EXPRS, + scalar_exprs: STAGE6_SCALAR_EXPRS, kernels: STAGE6_KERNELS, claims: STAGE6_SUMCHECK_CLAIMS, batches: STAGE6_SUMCHECK_BATCHES, @@ -813,7 +813,7 @@ where } })?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage6Error::from)?; artifacts.challenge_vectors.push(Stage6ChallengeVector { symbol: squeeze.symbol, @@ -893,7 +893,7 @@ where program.claims, program.batches, program.field_exprs, - program.value_exprs, + program.scalar_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -957,7 +957,7 @@ fn observe_stage6_sumcheck_output( }, )?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage6Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -1049,7 +1049,7 @@ fn expected_plan_relation_output( Ok(bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index f5fe1fbe16..1ed1971b26 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -23,8 +23,8 @@ pub use bolt_verifier_runtime::{ ClaimKind as Stage7ClaimKind, FieldConstantPlan as Stage7FieldConstantPlan, FieldExprKind as Stage7FieldExprKind, FieldExprPlan as Stage7FieldExprPlan, - ValueExprKind as Stage7ValueExprKind, - ValueExprPlan as Stage7ValueExprPlan, + ScalarExprKind as Stage7ScalarExprKind, + ScalarExprPlan as Stage7ScalarExprPlan, KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan, OpeningClaimEqualityPlan as Stage7OpeningClaimEqualityPlan, OpeningClaimPlan as Stage7OpeningClaimPlan, OpeningInputPlan as Stage7OpeningInputPlan, @@ -171,18 +171,18 @@ const fn stage7_field_expr(symbol: &'static str, kind: Stage7FieldExprKind, oper pub const STAGE7_FIELD_EXPRS: &[Stage7FieldExprPlan] = &[ ]; -const fn stage7_value_expr(symbol: &'static str, kind: Stage7ValueExprKind, operands: &'static [&'static str]) -> Stage7ValueExprPlan { - Stage7ValueExprPlan { symbol, kind, operands } +const fn stage7_scalar_expr(symbol: &'static str, kind: Stage7ScalarExprKind, operands: &'static [&'static str]) -> Stage7ScalarExprPlan { + Stage7ScalarExprPlan { symbol, kind, operands } } #[rustfmt::skip] -pub const STAGE7_VALUE_EXPRS: &[Stage7ValueExprPlan] = &[ - stage7_value_expr("stage7.hamming_weight_claim_reduction.input.claim_expr", Stage7ValueExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[], shared_term_offsets: &[], row_term_offsets: &[0, 1, 2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.booleanity.InstructionRa_0", "stage7.input.stage6.booleanity.InstructionRa_1", "stage7.input.stage6.booleanity.InstructionRa_2", "stage7.input.stage6.booleanity.InstructionRa_3", "stage7.input.stage6.booleanity.InstructionRa_4", "stage7.input.stage6.booleanity.InstructionRa_5", "stage7.input.stage6.booleanity.InstructionRa_6", "stage7.input.stage6.booleanity.InstructionRa_7", "stage7.input.stage6.booleanity.InstructionRa_8", "stage7.input.stage6.booleanity.InstructionRa_9", "stage7.input.stage6.booleanity.InstructionRa_10", "stage7.input.stage6.booleanity.InstructionRa_11", "stage7.input.stage6.booleanity.InstructionRa_12", "stage7.input.stage6.booleanity.InstructionRa_13", "stage7.input.stage6.booleanity.InstructionRa_14", "stage7.input.stage6.booleanity.InstructionRa_15", "stage7.input.stage6.booleanity.InstructionRa_16", "stage7.input.stage6.booleanity.InstructionRa_17", "stage7.input.stage6.booleanity.InstructionRa_18", "stage7.input.stage6.booleanity.InstructionRa_19", "stage7.input.stage6.booleanity.InstructionRa_20", "stage7.input.stage6.booleanity.InstructionRa_21", "stage7.input.stage6.booleanity.InstructionRa_22", "stage7.input.stage6.booleanity.InstructionRa_23", "stage7.input.stage6.booleanity.InstructionRa_24", "stage7.input.stage6.booleanity.InstructionRa_25", "stage7.input.stage6.booleanity.InstructionRa_26", "stage7.input.stage6.booleanity.InstructionRa_27", "stage7.input.stage6.booleanity.InstructionRa_28", "stage7.input.stage6.booleanity.InstructionRa_29", "stage7.input.stage6.booleanity.InstructionRa_30", "stage7.input.stage6.booleanity.InstructionRa_31", "stage7.input.stage6.booleanity.BytecodeRa_0", "stage7.input.stage6.booleanity.BytecodeRa_1", "stage7.input.stage6.booleanity.BytecodeRa_2", "stage7.input.stage6.booleanity.RamRa_0", "stage7.input.stage6.booleanity.RamRa_1", "stage7.input.stage6.booleanity.RamRa_2", "stage7.input.stage6.booleanity.RamRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_0", "stage7.input.stage6.ram_ra_virtual.RamRa_1", "stage7.input.stage6.ram_ra_virtual.RamRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.claim_expr", Stage7ValueExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.Booleanity", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.booleanity.InstructionRa_0"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"]), - stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"]), - stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"]), - stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"]), - stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_0"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_1"]), - stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_2"]), stage7_value_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", Stage7ValueExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), +pub const STAGE7_SCALAR_EXPRS: &[Stage7ScalarExprPlan] = &[ + stage7_scalar_expr("stage7.hamming_weight_claim_reduction.input.claim_expr", Stage7ScalarExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[], shared_term_offsets: &[], row_term_offsets: &[0, 1, 2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.field.one", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.hamming_booleanity.HammingWeight", "stage7.input.stage6.booleanity.InstructionRa_0", "stage7.input.stage6.booleanity.InstructionRa_1", "stage7.input.stage6.booleanity.InstructionRa_2", "stage7.input.stage6.booleanity.InstructionRa_3", "stage7.input.stage6.booleanity.InstructionRa_4", "stage7.input.stage6.booleanity.InstructionRa_5", "stage7.input.stage6.booleanity.InstructionRa_6", "stage7.input.stage6.booleanity.InstructionRa_7", "stage7.input.stage6.booleanity.InstructionRa_8", "stage7.input.stage6.booleanity.InstructionRa_9", "stage7.input.stage6.booleanity.InstructionRa_10", "stage7.input.stage6.booleanity.InstructionRa_11", "stage7.input.stage6.booleanity.InstructionRa_12", "stage7.input.stage6.booleanity.InstructionRa_13", "stage7.input.stage6.booleanity.InstructionRa_14", "stage7.input.stage6.booleanity.InstructionRa_15", "stage7.input.stage6.booleanity.InstructionRa_16", "stage7.input.stage6.booleanity.InstructionRa_17", "stage7.input.stage6.booleanity.InstructionRa_18", "stage7.input.stage6.booleanity.InstructionRa_19", "stage7.input.stage6.booleanity.InstructionRa_20", "stage7.input.stage6.booleanity.InstructionRa_21", "stage7.input.stage6.booleanity.InstructionRa_22", "stage7.input.stage6.booleanity.InstructionRa_23", "stage7.input.stage6.booleanity.InstructionRa_24", "stage7.input.stage6.booleanity.InstructionRa_25", "stage7.input.stage6.booleanity.InstructionRa_26", "stage7.input.stage6.booleanity.InstructionRa_27", "stage7.input.stage6.booleanity.InstructionRa_28", "stage7.input.stage6.booleanity.InstructionRa_29", "stage7.input.stage6.booleanity.InstructionRa_30", "stage7.input.stage6.booleanity.InstructionRa_31", "stage7.input.stage6.booleanity.BytecodeRa_0", "stage7.input.stage6.booleanity.BytecodeRa_1", "stage7.input.stage6.booleanity.BytecodeRa_2", "stage7.input.stage6.booleanity.RamRa_0", "stage7.input.stage6.booleanity.RamRa_1", "stage7.input.stage6.booleanity.RamRa_2", "stage7.input.stage6.booleanity.RamRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_0", "stage7.input.stage6.ram_ra_virtual.RamRa_1", "stage7.input.stage6.ram_ra_virtual.RamRa_2", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.claim_expr", Stage7ScalarExprKind::PowerStridedWeightedSum { row_count: 39, power_stride: 3, value_term_offsets: &[0], shared_term_offsets: &[1], row_term_offsets: &[2] }, &["stage7.hamming_weight_claim_reduction.gamma", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_2", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_3", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_4", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_5", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_6", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_7", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_8", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_9", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_10", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_11", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_12", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_13", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_14", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_15", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_16", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_17", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_18", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_19", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_20", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_21", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_22", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_23", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_24", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_25", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_26", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_27", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_28", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_29", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_30", "stage7.hamming_weight_claim_reduction.eval.InstructionRa_31", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_0", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_1", "stage7.hamming_weight_claim_reduction.eval.BytecodeRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_0", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.Booleanity", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.booleanity.InstructionRa_0"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4"]), + stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12"]), + stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20"]), + stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28"]), + stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_0"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_1"]), + stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_2"]), stage7_scalar_expr("stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", Stage7ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::XPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, &["stage7.hamming_weight_claim_reduction.instance", "stage7.input.stage6.ram_ra_virtual.RamRa_3"]), ]; pub const STAGE7_KERNELS: &[Stage7KernelPlan] = &[ @@ -381,7 +381,7 @@ pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan { opening_inputs: STAGE7_OPENING_INPUTS, field_constants: STAGE7_FIELD_CONSTANTS, field_exprs: STAGE7_FIELD_EXPRS, - value_exprs: STAGE7_VALUE_EXPRS, + scalar_exprs: STAGE7_SCALAR_EXPRS, kernels: STAGE7_KERNELS, claims: STAGE7_SUMCHECK_CLAIMS, batches: STAGE7_SUMCHECK_BATCHES, @@ -491,7 +491,7 @@ where } })?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage7Error::from)?; artifacts.challenge_vectors.push(Stage7ChallengeVector { symbol: squeeze.symbol, @@ -569,7 +569,7 @@ where program.claims, program.batches, program.field_exprs, - program.value_exprs, + program.scalar_exprs, program.opening_inputs, program.opening_claims, program.opening_batches, @@ -622,7 +622,7 @@ fn observe_stage7_sumcheck_output( }, )?; store - .evaluate_available_exprs(program.field_exprs, program.value_exprs) + .evaluate_available_exprs(program.field_exprs, program.scalar_exprs) .map_err(VerifyStage7Error::from)?; store.verify_opening_equalities( program.opening_equalities, @@ -669,7 +669,7 @@ fn expected_batched_output_claim( bolt_verifier_runtime::evaluate_relation_output_for_instance( program.relation_outputs, program.field_exprs, - program.value_exprs, + program.scalar_exprs, store, instance, evals, &[], &[], local_point, From 5c507df54cb3508d2355f9f67cdf44887bb275f4 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 00:01:02 -0600 Subject: [PATCH 111/171] refactor(bolt): type verifier point expressions --- crates/bolt-verifier-runtime/src/lib.rs | 138 +++---- .../src/protocols/jolt/emit/rust/stage2.rs | 80 ++-- .../src/protocols/jolt/emit/rust/stage3.rs | 59 ++- .../src/protocols/jolt/emit/rust/stage4.rs | 68 ++-- .../src/protocols/jolt/emit/rust/stage5.rs | 53 ++- .../src/protocols/jolt/emit/rust/stage6.rs | 75 ++-- .../src/protocols/jolt/emit/rust/stage7.rs | 75 ++-- .../bolt/src/protocols/jolt/verifier_plan.rs | 223 +++++------ .../jolt/verifier_relation_outputs.rs | 4 +- .../src/protocols/jolt/verifier_values.rs | 4 +- crates/jolt-equivalence/src/plan_adapters.rs | 357 +++++++++++++++++- .../src/plan_adapters/generated_stage2.rs | 4 +- .../src/plan_adapters/generated_stage3.rs | 4 +- .../src/plan_adapters/generated_stage4.rs | 4 +- .../src/plan_adapters/generated_stage5.rs | 4 +- .../src/plan_adapters/generated_stage6.rs | 6 +- .../src/plan_adapters/generated_stage7.rs | 6 +- crates/jolt-verifier/src/stages/stage2.rs | 18 +- crates/jolt-verifier/src/stages/stage3.rs | 16 +- crates/jolt-verifier/src/stages/stage4.rs | 25 +- crates/jolt-verifier/src/stages/stage5.rs | 61 ++- crates/jolt-verifier/src/stages/stage6.rs | 191 +++++----- crates/jolt-verifier/src/stages/stage7.rs | 28 +- 23 files changed, 826 insertions(+), 677 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index ebfa3ef1aa..0db55548f8 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -436,27 +436,17 @@ pub struct SumcheckEvalPlan { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct PointZeroPlan { - pub symbol: &'static str, - pub field: &'static str, - pub arity: usize, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct PointSlicePlan { - pub symbol: &'static str, - pub source: &'static str, - pub offset: usize, - pub length: usize, - pub input: &'static str, +pub enum PointExprKind { + Zero { field: &'static str, arity: usize }, + Slice { offset: usize, length: usize }, + Concat { layout: &'static str, arity: usize }, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct PointConcatPlan { +pub struct PointExprPlan { pub symbol: &'static str, - pub layout: &'static str, - pub arity: usize, - pub inputs: &'static [&'static str], + pub kind: PointExprKind, + pub operands: &'static [&'static str], } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -513,35 +503,7 @@ pub struct StageProgramPlan { pub evals: &'static [SumcheckEvalPlan], pub relation_output_values: &'static [StructuredPolynomialEvalPlan], pub relation_outputs: &'static [RelationOutputPlan], - pub point_zeros: &'static [PointZeroPlan], - pub point_slices: &'static [PointSlicePlan], - pub point_concats: &'static [PointConcatPlan], - pub opening_claims: &'static [OpeningClaimPlan], - pub opening_equalities: &'static [OpeningClaimEqualityPlan], - pub opening_batches: &'static [OpeningBatchPlan], -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageProgramPlanNoPointZeros { - pub role: &'static str, - pub params: StageParams, - pub steps: &'static [ProgramStepPlan], - pub transcript_squeezes: &'static [TranscriptSqueezePlan], - pub transcript_absorb_bytes: &'static [TranscriptAbsorbBytesPlan], - pub opening_inputs: &'static [OpeningInputPlan], - pub field_constants: &'static [FieldConstantPlan], - pub field_exprs: &'static [FieldExprPlan], - pub scalar_exprs: &'static [ScalarExprPlan], - pub kernels: &'static [KernelPlan], - pub claims: &'static [SumcheckClaimPlan], - pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], - pub evals: &'static [SumcheckEvalPlan], - pub relation_output_values: &'static [StructuredPolynomialEvalPlan], - pub relation_outputs: &'static [RelationOutputPlan], - pub point_slices: &'static [PointSlicePlan], - pub point_concats: &'static [PointConcatPlan], + pub point_exprs: &'static [PointExprPlan], pub opening_claims: &'static [OpeningClaimPlan], pub opening_equalities: &'static [OpeningClaimEqualityPlan], pub opening_batches: &'static [OpeningBatchPlan], @@ -563,8 +525,7 @@ pub struct StageVerifierProgramPlan { pub evals: &'static [SumcheckEvalPlan], pub relation_output_values: &'static [StructuredPolynomialEvalPlan], pub relation_outputs: &'static [RelationOutputPlan], - pub point_slices: &'static [PointSlicePlan], - pub point_concats: &'static [PointConcatPlan], + pub point_exprs: &'static [PointExprPlan], pub opening_claims: &'static [OpeningClaimPlan], pub opening_equalities: &'static [OpeningClaimEqualityPlan], pub opening_batches: &'static [OpeningBatchPlan], @@ -584,8 +545,7 @@ pub struct StageVerifierProgramPlanNoEqualities { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], - pub point_slices: &'static [PointSlicePlan], - pub point_concats: &'static [PointConcatPlan], + pub point_exprs: &'static [PointExprPlan], pub opening_claims: &'static [OpeningClaimPlan], pub opening_batches: &'static [OpeningBatchPlan], } @@ -863,12 +823,6 @@ impl ValueStore { } } - pub fn seed_point_zeros(&mut self, point_zeros: &[PointZeroPlan]) { - for zero in point_zeros { - self.insert_point(zero.symbol, vec![F::from_u64(0); zero.arity]); - } - } - pub fn observe_challenge_vector( &mut self, plan: &TranscriptSqueezePlan, @@ -923,42 +877,19 @@ impl ValueStore { pub fn evaluate_available_points( &mut self, - point_slices: &[PointSlicePlan], - point_concats: &[PointConcatPlan], + point_exprs: &[PointExprPlan], invalid_input_length: impl Fn(&'static str, usize, usize) -> E, ) -> Result<(), E> { loop { let mut progress = 0usize; - for slice in point_slices { - if self.try_point(slice.symbol).is_some() { + for expr in point_exprs { + if self.try_point(expr.symbol).is_some() { continue; } - let Some(input) = self.try_point(slice.input) else { + let Some(point) = self.try_point_expr(expr, &invalid_input_length)? else { continue; }; - let end = slice.offset + slice.length; - let point = input - .get(slice.offset..end) - .ok_or_else(|| invalid_input_length(slice.symbol, end, input.len()))? - .to_vec(); - self.insert_point(slice.symbol, point); - progress += 1; - } - for concat in point_concats { - if self.try_point(concat.symbol).is_some() { - continue; - } - let Some(point) = self.try_concat_point(concat) else { - continue; - }; - if point.len() != concat.arity { - return Err(invalid_input_length( - concat.symbol, - concat.arity, - point.len(), - )); - } - self.insert_point(concat.symbol, point); + self.insert_point(expr.symbol, point); progress += 1; } if progress == 0 { @@ -1167,12 +1098,41 @@ impl ValueStore { } } - fn try_concat_point(&self, concat: &PointConcatPlan) -> Option> { - let mut point = Vec::with_capacity(concat.arity); - for input in concat.inputs { - point.extend_from_slice(self.try_point(input)?); + fn try_point_expr( + &self, + expr: &PointExprPlan, + invalid_input_length: &impl Fn(&'static str, usize, usize) -> E, + ) -> Result>, E> { + match expr.kind { + PointExprKind::Zero { arity, .. } => Ok(Some(vec![F::from_u64(0); arity])), + PointExprKind::Slice { offset, length } => { + let [input] = expr.operands else { + return Err(invalid_input_length(expr.symbol, 1, expr.operands.len())); + }; + let Some(point) = self.try_point(input) else { + return Ok(None); + }; + let end = offset + length; + let point = point + .get(offset..end) + .ok_or_else(|| invalid_input_length(expr.symbol, end, point.len()))? + .to_vec(); + Ok(Some(point)) + } + PointExprKind::Concat { arity, .. } => { + let mut point = Vec::with_capacity(arity); + for input in expr.operands { + let Some(input) = self.try_point(input) else { + return Ok(None); + }; + point.extend_from_slice(input); + } + if point.len() != arity { + return Err(invalid_input_length(expr.symbol, arity, point.len())); + } + Ok(Some(point)) + } } - Some(point) } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 78bf12f593..27f8279d5e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -10,6 +10,7 @@ use crate::protocols::jolt::rust_target_plan::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, ProgramStepKind, RustTargetPlanError, TranscriptSqueezeKind, }; +use crate::protocols::jolt::verifier_plan; use crate::schema::verify_cpu_schema; #[derive(Clone, Debug, PartialEq, Eq)] @@ -1002,8 +1003,8 @@ pub use bolt_verifier_runtime::{ FieldExprPlan as Stage2FieldExprPlan, ScalarExprPlan as Stage2ScalarExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, - OpeningInputPlan as Stage2OpeningInputPlan, PointConcatPlan as Stage2PointConcatPlan, - PointSlicePlan as Stage2PointSlicePlan, ProgramStepKind as Stage2ProgramStepKind, + OpeningInputPlan as Stage2OpeningInputPlan, PointExprKind as Stage2PointExprKind, + PointExprPlan as Stage2PointExprPlan, ProgramStepKind as Stage2ProgramStepKind, ProgramStepPlan as Stage2ProgramStepPlan, StageParams as Stage2Params, SumcheckBatchPlan as Stage2SumcheckBatchPlan, SumcheckEvalPlan as Stage2SumcheckEvalPlan, @@ -1115,8 +1116,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); \x20 drivers: STAGE2_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE2_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE2_SUMCHECK_EVALS,\n\ - \x20 point_slices: STAGE2_POINT_SLICES,\n\ - \x20 point_concats: STAGE2_POINT_CONCATS,\n\ + \x20 point_exprs: STAGE2_POINT_EXPRS,\n\ \x20 opening_claims: STAGE2_OPENING_CLAIMS,\n\ \x20 opening_batches: STAGE2_OPENING_BATCHES,\n\ };\n", @@ -1546,8 +1546,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); let mut source = String::new(); source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); - source.push_str(&self.emit_point_slice_constants()); - source.push_str(&self.emit_point_concat_constants()); + source.push_str(&self.emit_point_expr_constants()?); source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_batch_constants()); Ok(source) @@ -1605,7 +1604,38 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); format!("pub const STAGE2_SUMCHECK_EVALS: &[Stage2SumcheckEvalPlan] = &[\n{evals}\n];\n\n") } - fn emit_point_slice_constants(&self) -> String { + fn emit_point_expr_constants(&self) -> Result { + if self.role == Role::Verifier { + let mut point_exprs = self + .point_slices + .iter() + .map(|slice| verifier_plan::VerifierPointExprPlan { + symbol: slice.symbol.clone(), + kind: verifier_plan::VerifierPointExprKind::Slice { + offset: slice.offset, + length: slice.length, + }, + operands: vec![slice.input.clone()], + }) + .collect::>(); + point_exprs.extend(self.point_concats.iter().map(|concat| { + verifier_plan::VerifierPointExprPlan { + symbol: concat.symbol.clone(), + kind: verifier_plan::VerifierPointExprKind::Concat { + layout: concat.layout.clone(), + arity: concat.arity, + }, + operands: concat.inputs.clone(), + } + })); + return Ok(verifier_plan::emit_point_expr_constants( + "Stage2", + "STAGE2", + &point_exprs, + )); + } + + let mut source = String::new(); let slices = self .point_slices .iter() @@ -1621,31 +1651,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); }) .collect::>() .join("\n"); - format!("pub const STAGE2_POINT_SLICES: &[Stage2PointSlicePlan] = &[\n{slices}\n];\n\n") - } - - fn emit_point_concat_constants(&self) -> String { - if self.role == Role::Verifier { - let concats = self - .point_concats - .iter() - .map(|concat| { - format!( - " Stage2PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},", - rust_str(&concat.symbol), - rust_str(&concat.layout), - concat.arity, - super::plan_tokens::rust_str_slice_expr(&concat.inputs) - ) - }) - .collect::>() - .join("\n"); - return format!( - "pub const STAGE2_POINT_CONCATS: &[Stage2PointConcatPlan] = &[\n{concats}\n];\n" - ); - } - - let mut source = String::new(); + push_format( + &mut source, + format_args!( + "pub const STAGE2_POINT_SLICES: &[Stage2PointSlicePlan] = &[\n{slices}\n];\n\n" + ), + ); for (index, concat) in self.point_concats.iter().enumerate() { source.push_str(&emit_str_array( &format!("STAGE2_POINT_CONCAT_{index}_INPUTS"), @@ -1672,7 +1683,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); "pub const STAGE2_POINT_CONCATS: &[Stage2PointConcatPlan] = &[\n{concats}\n];\n" ), ); - source + Ok(source) } fn emit_opening_claim_constants(&self) -> Result { @@ -2150,8 +2161,7 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, ) -> Result<(), VerifyStage2Error> { self.0.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage2Error::InvalidInputLength { input, expected, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 30f7586463..934bffdb16 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1216,7 +1216,7 @@ pub use bolt_verifier_runtime::{ OpeningBatchPlan as Stage3OpeningBatchPlan, OpeningClaimEqualityPlan as Stage3OpeningClaimEqualityPlan, OpeningClaimPlan as Stage3OpeningClaimPlan, OpeningInputPlan as Stage3OpeningInputPlan, - PointConcatPlan as Stage3PointConcatPlan, PointSlicePlan as Stage3PointSlicePlan, + PointExprKind as Stage3PointExprKind, PointExprPlan as Stage3PointExprPlan, OpeningEqualityMode as Stage3OpeningEqualityMode, ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, @@ -1301,8 +1301,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); \x20 evals: STAGE3_SUMCHECK_EVALS,\n\ \x20 relation_output_values: STAGE3_RELATION_OUTPUT_VALUES,\n\ \x20 relation_outputs: STAGE3_RELATION_OUTPUTS,\n\ - \x20 point_slices: STAGE3_POINT_SLICES,\n\ - \x20 point_concats: STAGE3_POINT_CONCATS,\n\ + \x20 point_exprs: STAGE3_POINT_EXPRS,\n\ \x20 opening_claims: STAGE3_OPENING_CLAIMS,\n\ \x20 opening_equalities: STAGE3_OPENING_EQUALITIES,\n\ \x20 opening_batches: STAGE3_OPENING_BATCHES,\n\ @@ -1712,8 +1711,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); let mut source = String::new(); source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); - source.push_str(&self.emit_point_slice_constants()); - source.push_str(&self.emit_point_concat_constants()); + source.push_str(&self.emit_point_constants()?); source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_claim_equality_constants()?); source.push_str(&self.emit_opening_batch_constants()); @@ -1789,7 +1787,17 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); ) } - fn emit_point_slice_constants(&self) -> String { + fn emit_point_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_point_expr_constants( + "Stage3", + "STAGE3", + &plan.point_exprs, + )); + } + + let mut source = String::new(); let slices = self .point_slices .iter() @@ -1805,31 +1813,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); }) .collect::>() .join("\n"); - format!("pub const STAGE3_POINT_SLICES: &[Stage3PointSlicePlan] = &[\n{slices}\n];\n\n") - } - - fn emit_point_concat_constants(&self) -> String { - if self.role == Role::Verifier { - let concats = self - .point_concats - .iter() - .map(|concat| { - format!( - " Stage3PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},", - rust_str(&concat.symbol), - rust_str(&concat.layout), - concat.arity, - super::plan_tokens::rust_str_slice_expr(&concat.inputs) - ) - }) - .collect::>() - .join("\n"); - return format!( - "pub const STAGE3_POINT_CONCATS: &[Stage3PointConcatPlan] = &[\n{concats}\n];\n" - ); - } - - let mut source = String::new(); + push_format( + &mut source, + format_args!( + "pub const STAGE3_POINT_SLICES: &[Stage3PointSlicePlan] = &[\n{slices}\n];\n\n" + ), + ); for (index, concat) in self.point_concats.iter().enumerate() { source.push_str(&emit_str_array( &format!("STAGE3_POINT_CONCAT_{index}_INPUTS"), @@ -1856,7 +1845,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); "pub const STAGE3_POINT_CONCATS: &[Stage3PointConcatPlan] = &[\n{concats}\n];\n" ), ); - source + Ok(source) } fn emit_opening_claim_constants(&self) -> Result { @@ -2144,8 +2133,7 @@ where T: Transcript, { store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage3Error::InvalidInputLength { input, expected, @@ -2202,8 +2190,7 @@ fn observe_stage3_sumcheck_output( |symbol| VerifyStage3Error::MissingValue { symbol }, )?; store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage3Error::InvalidInputLength { input, expected, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 7f68314fb6..d41cc9af09 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -1411,7 +1411,7 @@ pub type Stage4ChallengeVector = bolt_verifier_runtime::StageChallengeVector< pub type Stage4ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; pub type Stage4Proof = bolt_verifier_runtime::StageProof; pub type Stage4OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; -pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZeros; +pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage4SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; @@ -1428,8 +1428,8 @@ pub use bolt_verifier_runtime::{ KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan, OpeningClaimEqualityPlan as Stage4OpeningClaimEqualityPlan, OpeningClaimPlan as Stage4OpeningClaimPlan, OpeningInputPlan as Stage4OpeningInputPlan, - OpeningEqualityMode as Stage4OpeningEqualityMode, - PointConcatPlan as Stage4PointConcatPlan, PointSlicePlan as Stage4PointSlicePlan, + OpeningEqualityMode as Stage4OpeningEqualityMode, PointExprKind as Stage4PointExprKind, + PointExprPlan as Stage4PointExprPlan, ProgramStepKind as Stage4ProgramStepKind, ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, SumcheckBatchPlan as Stage4SumcheckBatchPlan, @@ -1492,6 +1492,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } else { "" }; + let point_exprs_field = if self.role == Role::Verifier { + " point_exprs: STAGE4_POINT_EXPRS,\n" + } else { + " point_slices: STAGE4_POINT_SLICES,\n point_concats: STAGE4_POINT_CONCATS,\n" + }; push_format( &mut source, format_args!( @@ -1512,8 +1517,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); \x20 instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE4_SUMCHECK_EVALS,\n\ {relation_outputs_field}\ - \x20 point_slices: STAGE4_POINT_SLICES,\n\ - \x20 point_concats: STAGE4_POINT_CONCATS,\n\ + {point_exprs_field}\ \x20 opening_claims: STAGE4_OPENING_CLAIMS,\n\ \x20 opening_equalities: STAGE4_OPENING_EQUALITIES,\n\ \x20 opening_batches: STAGE4_OPENING_BATCHES,\n\ @@ -1945,8 +1949,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); let mut source = String::new(); source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); - source.push_str(&self.emit_point_slice_constants()); - source.push_str(&self.emit_point_concat_constants()); + source.push_str(&self.emit_point_constants()?); source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_claim_equality_constants()?); source.push_str(&self.emit_opening_batch_constants()); @@ -2022,7 +2025,17 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); ) } - fn emit_point_slice_constants(&self) -> String { + fn emit_point_constants(&self) -> Result { + if self.role == Role::Verifier { + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_point_expr_constants( + "Stage4", + "STAGE4", + &plan.point_exprs, + )); + } + + let mut source = String::new(); let slices = self .point_slices .iter() @@ -2038,31 +2051,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); }) .collect::>() .join("\n"); - format!("pub const STAGE4_POINT_SLICES: &[Stage4PointSlicePlan] = &[\n{slices}\n];\n\n") - } - - fn emit_point_concat_constants(&self) -> String { - if self.role == Role::Verifier { - let concats = self - .point_concats - .iter() - .map(|concat| { - format!( - " Stage4PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},", - rust_str(&concat.symbol), - rust_str(&concat.layout), - concat.arity, - super::plan_tokens::rust_str_slice_expr(&concat.inputs) - ) - }) - .collect::>() - .join("\n"); - return format!( - "pub const STAGE4_POINT_CONCATS: &[Stage4PointConcatPlan] = &[\n{concats}\n];\n" - ); - } - - let mut source = String::new(); + push_format( + &mut source, + format_args!( + "pub const STAGE4_POINT_SLICES: &[Stage4PointSlicePlan] = &[\n{slices}\n];\n\n" + ), + ); for (index, concat) in self.point_concats.iter().enumerate() { source.push_str(&emit_str_array( &format!("STAGE4_POINT_CONCAT_{index}_INPUTS"), @@ -2089,7 +2083,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); "pub const STAGE4_POINT_CONCATS: &[Stage4PointConcatPlan] = &[\n{concats}\n];\n" ), ); - source + Ok(source) } fn emit_opening_claim_constants(&self) -> Result { @@ -2387,8 +2381,7 @@ where T: Transcript, { store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage4Error::InvalidInputLength { input, expected, @@ -2448,8 +2441,7 @@ fn observe_stage4_sumcheck_output( |symbol| VerifyStage4Error::MissingValue { symbol }, )?; store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage4Error::InvalidInputLength { input, expected, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index edf17c059c..678a7a2509 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1537,7 +1537,7 @@ pub type Stage5ChallengeVector = bolt_verifier_runtime::StageChallengeVector< pub type Stage5ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; pub type Stage5Proof = bolt_verifier_runtime::StageProof; pub type Stage5OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; -pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZeros; +pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage5SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; @@ -1554,8 +1554,8 @@ pub use bolt_verifier_runtime::{ KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan, OpeningClaimEqualityPlan as Stage5OpeningClaimEqualityPlan, OpeningClaimPlan as Stage5OpeningClaimPlan, OpeningInputPlan as Stage5OpeningInputPlan, - OpeningEqualityMode as Stage5OpeningEqualityMode, - PointConcatPlan as Stage5PointConcatPlan, PointSlicePlan as Stage5PointSlicePlan, + OpeningEqualityMode as Stage5OpeningEqualityMode, PointExprKind as Stage5PointExprKind, + PointExprPlan as Stage5PointExprPlan, ProgramStepKind as Stage5ProgramStepKind, ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params, SumcheckBatchPlan as Stage5SumcheckBatchPlan, @@ -1619,6 +1619,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } else { "" }; + let point_exprs_field = if self.role == Role::Verifier { + " point_exprs: STAGE5_POINT_EXPRS,\n" + } else { + " point_slices: STAGE5_POINT_SLICES,\n point_concats: STAGE5_POINT_CONCATS,\n" + }; push_format( &mut source, format_args!( @@ -1639,8 +1644,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); \x20 instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE5_SUMCHECK_EVALS,\n\ {relation_outputs_field}\ - \x20 point_slices: STAGE5_POINT_SLICES,\n\ - \x20 point_concats: STAGE5_POINT_CONCATS,\n\ + {point_exprs_field}\ \x20 opening_claims: STAGE5_OPENING_CLAIMS,\n\ \x20 opening_equalities: STAGE5_OPENING_EQUALITIES,\n\ \x20 opening_batches: STAGE5_OPENING_BATCHES,\n\ @@ -2048,8 +2052,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); if self.role == Role::Verifier { source.push_str(&self.emit_named_eval_family_constants()?); } - source.push_str(&self.emit_point_slice_constants()?); - source.push_str(&self.emit_point_concat_constants()?); + source.push_str(&self.emit_point_constants()?); source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_claim_equality_constants()?); source.push_str(&self.emit_opening_batch_constants()?); @@ -2142,15 +2145,17 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); ) } - fn emit_point_slice_constants(&self) -> Result { + fn emit_point_constants(&self) -> Result { if self.role == Role::Verifier { let plan = self.verifier_plan()?; - return Ok(verifier_plan::emit_point_slice_constants( + return Ok(verifier_plan::emit_point_expr_constants( "Stage5", "STAGE5", - &plan.point_slices, + &plan.point_exprs, )); } + + let mut source = String::new(); let slices = self .point_slices .iter() @@ -2166,22 +2171,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); }) .collect::>() .join("\n"); - Ok(format!( - "pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[\n{slices}\n];\n\n" - )) - } - - fn emit_point_concat_constants(&self) -> Result { - if self.role == Role::Verifier { - let plan = self.verifier_plan()?; - return Ok(verifier_plan::emit_point_concat_constants( - "Stage5", - "STAGE5", - &plan.point_concats, - )); - } - - let mut source = String::new(); + push_format( + &mut source, + format_args!( + "pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[\n{slices}\n];\n\n" + ), + ); for (index, concat) in self.point_concats.iter().enumerate() { source.push_str(&emit_str_array( &format!("STAGE5_POINT_CONCAT_{index}_INPUTS"), @@ -2492,8 +2487,7 @@ where T: Transcript, { store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage5Error::InvalidInputLength { input, expected, @@ -2554,8 +2548,7 @@ fn observe_stage5_sumcheck_output( )?; store.evaluate_named_eval_families(STAGE5_INDEXED_EVAL_FAMILIES)?; store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage5Error::InvalidInputLength { input, expected, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index a3d169181c..d9de58b938 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1570,9 +1570,8 @@ pub use bolt_verifier_runtime::{ KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan, OpeningClaimEqualityPlan as Stage6OpeningClaimEqualityPlan, OpeningClaimPlan as Stage6OpeningClaimPlan, OpeningInputPlan as Stage6OpeningInputPlan, - OpeningEqualityMode as Stage6OpeningEqualityMode, - PointConcatPlan as Stage6PointConcatPlan, PointSlicePlan as Stage6PointSlicePlan, - PointZeroPlan as Stage6PointZeroPlan, ProgramStepKind as Stage6ProgramStepKind, + OpeningEqualityMode as Stage6OpeningEqualityMode, PointExprKind as Stage6PointExprKind, + PointExprPlan as Stage6PointExprPlan, ProgramStepKind as Stage6ProgramStepKind, ProgramStepPlan as Stage6ProgramStepPlan, StageParams as Stage6Params, SumcheckBatchPlan as Stage6SumcheckBatchPlan, @@ -1698,6 +1697,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); } else { "" }; + let point_exprs_field = if self.role == Role::Verifier { + " point_exprs: STAGE6_POINT_EXPRS,\n" + } else { + " point_zeros: STAGE6_POINT_ZEROS,\n point_slices: STAGE6_POINT_SLICES,\n point_concats: STAGE6_POINT_CONCATS,\n" + }; push_format( &mut source, format_args!( @@ -1718,9 +1722,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); \x20 instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE6_SUMCHECK_EVALS,\n\ {relation_outputs_field}\ - \x20 point_zeros: STAGE6_POINT_ZEROS,\n\ - \x20 point_slices: STAGE6_POINT_SLICES,\n\ - \x20 point_concats: STAGE6_POINT_CONCATS,\n\ + {point_exprs_field}\ \x20 opening_claims: STAGE6_OPENING_CLAIMS,\n\ \x20 opening_equalities: STAGE6_OPENING_EQUALITIES,\n\ \x20 opening_batches: STAGE6_OPENING_BATCHES,\n\ @@ -2129,9 +2131,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); let mut source = String::new(); source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); - source.push_str(&self.emit_point_zero_constants()?); - source.push_str(&self.emit_point_slice_constants()?); - source.push_str(&self.emit_point_concat_constants()?); + source.push_str(&self.emit_point_constants()?); source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_claim_equality_constants()?); source.push_str(&self.emit_opening_batch_constants()?); @@ -2226,15 +2226,17 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); ) } - fn emit_point_zero_constants(&self) -> Result { + fn emit_point_constants(&self) -> Result { if self.role == Role::Verifier { let plan = self.verifier_plan()?; - return Ok(verifier_plan::emit_point_zero_constants( + return Ok(verifier_plan::emit_point_expr_constants( "Stage6", "STAGE6", - &plan.point_zeros, + &plan.point_exprs, )); } + + let mut source = String::new(); let zeros = self .point_zeros .iter() @@ -2248,20 +2250,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); }) .collect::>() .join("\n"); - Ok(format!( - "pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[\n{zeros}\n];\n\n" - )) - } - - fn emit_point_slice_constants(&self) -> Result { - if self.role == Role::Verifier { - let plan = self.verifier_plan()?; - return Ok(verifier_plan::emit_point_slice_constants( - "Stage6", - "STAGE6", - &plan.point_slices, - )); - } + push_format( + &mut source, + format_args!( + "pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[\n{zeros}\n];\n\n" + ), + ); let slices = self .point_slices .iter() @@ -2277,22 +2271,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); }) .collect::>() .join("\n"); - Ok(format!( - "pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[\n{slices}\n];\n\n" - )) - } - - fn emit_point_concat_constants(&self) -> Result { - if self.role == Role::Verifier { - let plan = self.verifier_plan()?; - return Ok(verifier_plan::emit_point_concat_constants( - "Stage6", - "STAGE6", - &plan.point_concats, - )); - } - - let mut source = String::new(); + push_format( + &mut source, + format_args!( + "pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[\n{slices}\n];\n\n" + ), + ); for (index, concat) in self.point_concats.iter().enumerate() { source.push_str(&emit_str_array( &format!("STAGE6_POINT_CONCAT_{index}_INPUTS"), @@ -2485,7 +2469,6 @@ where let mut store = bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); - store.seed_point_zeros(program.point_zeros); let mut artifacts = Stage6ExecutionArtifacts::default(); for step in program.steps { match step.kind { @@ -2620,8 +2603,7 @@ where T: Transcript, { store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage6Error::InvalidInputLength { input, expected, @@ -2689,8 +2671,7 @@ fn observe_stage6_sumcheck_output( )?; store.evaluate_named_eval_families(STAGE6_INDEXED_EVAL_FAMILIES)?; store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage6Error::InvalidInputLength { input, expected, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 61d41e5d71..2cb450a864 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1684,9 +1684,8 @@ pub use bolt_verifier_runtime::{ KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan, OpeningClaimEqualityPlan as Stage7OpeningClaimEqualityPlan, OpeningClaimPlan as Stage7OpeningClaimPlan, OpeningInputPlan as Stage7OpeningInputPlan, - OpeningEqualityMode as Stage7OpeningEqualityMode, - PointConcatPlan as Stage7PointConcatPlan, PointSlicePlan as Stage7PointSlicePlan, - PointZeroPlan as Stage7PointZeroPlan, ProgramStepKind as Stage7ProgramStepKind, + OpeningEqualityMode as Stage7OpeningEqualityMode, PointExprKind as Stage7PointExprKind, + PointExprPlan as Stage7PointExprPlan, ProgramStepKind as Stage7ProgramStepKind, ProgramStepPlan as Stage7ProgramStepPlan, StageParams as Stage7Params, SumcheckBatchPlan as Stage7SumcheckBatchPlan, @@ -1749,6 +1748,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); } else { "" }; + let point_exprs_field = if self.role == Role::Verifier { + " point_exprs: STAGE7_POINT_EXPRS,\n" + } else { + " point_zeros: STAGE7_POINT_ZEROS,\n point_slices: STAGE7_POINT_SLICES,\n point_concats: STAGE7_POINT_CONCATS,\n" + }; push_format( &mut source, format_args!( @@ -1769,9 +1773,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); \x20 instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE7_SUMCHECK_EVALS,\n\ {relation_outputs_field}\ - \x20 point_zeros: STAGE7_POINT_ZEROS,\n\ - \x20 point_slices: STAGE7_POINT_SLICES,\n\ - \x20 point_concats: STAGE7_POINT_CONCATS,\n\ + {point_exprs_field}\ \x20 opening_claims: STAGE7_OPENING_CLAIMS,\n\ \x20 opening_equalities: STAGE7_OPENING_EQUALITIES,\n\ \x20 opening_batches: STAGE7_OPENING_BATCHES,\n\ @@ -2180,9 +2182,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); let mut source = String::new(); source.push_str(&self.emit_sumcheck_instance_result_constants()?); source.push_str(&self.emit_sumcheck_eval_constants()); - source.push_str(&self.emit_point_zero_constants()?); - source.push_str(&self.emit_point_slice_constants()?); - source.push_str(&self.emit_point_concat_constants()?); + source.push_str(&self.emit_point_constants()?); source.push_str(&self.emit_opening_claim_constants()?); source.push_str(&self.emit_opening_claim_equality_constants()?); source.push_str(&self.emit_opening_batch_constants()?); @@ -2267,15 +2267,17 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); ) } - fn emit_point_zero_constants(&self) -> Result { + fn emit_point_constants(&self) -> Result { if self.role == Role::Verifier { let plan = self.verifier_plan()?; - return Ok(verifier_plan::emit_point_zero_constants( + return Ok(verifier_plan::emit_point_expr_constants( "Stage7", "STAGE7", - &plan.point_zeros, + &plan.point_exprs, )); } + + let mut source = String::new(); let zeros = self .point_zeros .iter() @@ -2289,20 +2291,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); }) .collect::>() .join("\n"); - Ok(format!( - "pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[\n{zeros}\n];\n\n" - )) - } - - fn emit_point_slice_constants(&self) -> Result { - if self.role == Role::Verifier { - let plan = self.verifier_plan()?; - return Ok(verifier_plan::emit_point_slice_constants( - "Stage7", - "STAGE7", - &plan.point_slices, - )); - } + push_format( + &mut source, + format_args!( + "pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[\n{zeros}\n];\n\n" + ), + ); let slices = self .point_slices .iter() @@ -2318,22 +2312,12 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); }) .collect::>() .join("\n"); - Ok(format!( - "pub const STAGE7_POINT_SLICES: &[Stage7PointSlicePlan] = &[\n{slices}\n];\n\n" - )) - } - - fn emit_point_concat_constants(&self) -> Result { - if self.role == Role::Verifier { - let plan = self.verifier_plan()?; - return Ok(verifier_plan::emit_point_concat_constants( - "Stage7", - "STAGE7", - &plan.point_concats, - )); - } - - let mut source = String::new(); + push_format( + &mut source, + format_args!( + "pub const STAGE7_POINT_SLICES: &[Stage7PointSlicePlan] = &[\n{slices}\n];\n\n" + ), + ); for (index, concat) in self.point_concats.iter().enumerate() { source.push_str(&emit_str_array( &format!("STAGE7_POINT_CONCAT_{index}_INPUTS"), @@ -2524,7 +2508,6 @@ where let mut store = bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); - store.seed_point_zeros(program.point_zeros); let mut artifacts = Stage7ExecutionArtifacts::default(); for step in program.steps { match step.kind { @@ -2652,8 +2635,7 @@ where T: Transcript, { store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage7Error::InvalidInputLength { input, expected, @@ -2710,8 +2692,7 @@ fn observe_stage7_sumcheck_output( |symbol| VerifyStage7Error::MissingValue { symbol }, )?; store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage7Error::InvalidInputLength { input, expected, diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 7fd2c84791..7c4960826a 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -218,27 +218,17 @@ pub(crate) struct VerifierSumcheckInstanceResultPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct VerifierPointZeroPlan { - pub(crate) symbol: String, - pub(crate) field: String, - pub(crate) arity: usize, +pub(crate) enum VerifierPointExprKind { + Zero { field: String, arity: usize }, + Slice { offset: usize, length: usize }, + Concat { layout: String, arity: usize }, } #[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct VerifierPointSlicePlan { +pub(crate) struct VerifierPointExprPlan { pub(crate) symbol: String, - pub(crate) source: String, - pub(crate) offset: usize, - pub(crate) length: usize, - pub(crate) input: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct VerifierPointConcatPlan { - pub(crate) symbol: String, - pub(crate) layout: String, - pub(crate) arity: usize, - pub(crate) inputs: Vec, + pub(crate) kind: VerifierPointExprKind, + pub(crate) operands: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -291,9 +281,7 @@ pub(crate) struct VerifierStagePlan { pub(crate) relation_output_product_families: Vec, pub(crate) relation_output_function_families: Vec, pub(crate) relation_outputs: Vec, - pub(crate) point_zeros: Vec, - pub(crate) point_slices: Vec, - pub(crate) point_concats: Vec, + pub(crate) point_exprs: Vec, pub(crate) opening_claims: Vec, pub(crate) opening_equalities: Vec, pub(crate) opening_batches: Vec, @@ -397,16 +385,8 @@ impl VerifierStagePlan { VerifierPointSourceKind::OpeningInput, ); values.extend( - self.point_zeros.iter().map(|zero| &zero.symbol), - VerifierPointSourceKind::PointZero, - ); - values.extend( - self.point_slices.iter().map(|slice| &slice.symbol), - VerifierPointSourceKind::PointSlice, - ); - values.extend( - self.point_concats.iter().map(|concat| &concat.symbol), - VerifierPointSourceKind::PointConcat, + self.point_exprs.iter().map(|expr| &expr.symbol), + VerifierPointSourceKind::PointExpr, ); values } @@ -420,13 +400,7 @@ impl VerifierStagePlan { .map(|instance| instance.symbol.clone()), ); values.extend(self.opening_inputs.iter().map(|input| input.symbol.clone())); - values.extend(self.point_zeros.iter().map(|zero| zero.symbol.clone())); - values.extend(self.point_slices.iter().map(|slice| slice.symbol.clone())); - values.extend( - self.point_concats - .iter() - .map(|concat| concat.symbol.clone()), - ); + values.extend(self.point_exprs.iter().map(|expr| expr.symbol.clone())); values } } @@ -543,7 +517,6 @@ pub(crate) trait VerifierPointZeroSource { pub(crate) trait VerifierPointSliceSource { fn symbol(&self) -> &str; - fn source(&self) -> &str; fn offset(&self) -> usize; fn length(&self) -> usize; fn input(&self) -> &str; @@ -625,9 +598,7 @@ pub(crate) trait VerifierStagePlanSource { &[] } fn relation_outputs(&self) -> &[RelationOutputPlan]; - fn point_zeros(&self) -> Vec; - fn point_slices(&self) -> &[Self::PointSlice]; - fn point_concats(&self) -> &[Self::PointConcat]; + fn point_exprs(&self) -> Vec; fn opening_claims(&self) -> &[Self::OpeningClaim]; fn opening_equalities(&self) -> &[Self::OpeningEquality]; fn opening_batches(&self) -> &[Self::OpeningBatch]; @@ -789,28 +760,7 @@ where relation_output_product_families: source.relation_output_product_families().to_vec(), relation_output_function_families: source.relation_output_function_families().to_vec(), relation_outputs: source.relation_outputs().to_vec(), - point_zeros: source.point_zeros(), - point_slices: source - .point_slices() - .iter() - .map(|slice| VerifierPointSlicePlan { - symbol: slice.symbol().to_owned(), - source: slice.source().to_owned(), - offset: slice.offset(), - length: slice.length(), - input: slice.input().to_owned(), - }) - .collect(), - point_concats: source - .point_concats() - .iter() - .map(|concat| VerifierPointConcatPlan { - symbol: concat.symbol().to_owned(), - layout: concat.layout().to_owned(), - arity: concat.arity(), - inputs: concat.inputs().to_vec(), - }) - .collect(), + point_exprs: source.point_exprs(), opening_claims: source .opening_claims() .iter() @@ -869,15 +819,50 @@ pub(crate) fn transcript_absorb_bytes_from_cpu( +pub(crate) fn point_zero_exprs_from_cpu( zeros: &[T], -) -> Vec { +) -> Vec { zeros .iter() - .map(|zero| VerifierPointZeroPlan { + .map(|zero| VerifierPointExprPlan { symbol: zero.symbol().to_owned(), - field: zero.field().to_owned(), - arity: zero.arity(), + kind: VerifierPointExprKind::Zero { + field: zero.field().to_owned(), + arity: zero.arity(), + }, + operands: Vec::new(), + }) + .collect() +} + +pub(crate) fn point_slice_exprs_from_cpu( + slices: &[T], +) -> Vec { + slices + .iter() + .map(|slice| VerifierPointExprPlan { + symbol: slice.symbol().to_owned(), + kind: VerifierPointExprKind::Slice { + offset: slice.offset(), + length: slice.length(), + }, + operands: vec![slice.input().to_owned()], + }) + .collect() +} + +pub(crate) fn point_concat_exprs_from_cpu( + concats: &[T], +) -> Vec { + concats + .iter() + .map(|concat| VerifierPointExprPlan { + symbol: concat.symbol().to_owned(), + kind: VerifierPointExprKind::Concat { + layout: concat.layout().to_owned(), + arity: concat.arity(), + }, + operands: concat.inputs().to_vec(), }) .collect() } @@ -969,13 +954,22 @@ macro_rules! impl_verifier_plan_source_traits { fn relation_outputs(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::RelationOutputPlan] { &self.relation_outputs } - fn point_zeros(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierPointZeroPlan> { - $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( - @point_zeros self $(, $point_zero)? - ) + fn point_exprs(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierPointExprPlan> { + let mut exprs = $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( + @point_zero_exprs self $(, $point_zero)? + ); + exprs.extend( + $crate::protocols::jolt::verifier_plan::point_slice_exprs_from_cpu( + &self.point_slices, + ), + ); + exprs.extend( + $crate::protocols::jolt::verifier_plan::point_concat_exprs_from_cpu( + &self.point_concats, + ), + ); + exprs } - fn point_slices(&self) -> &[Self::PointSlice] { &self.point_slices } - fn point_concats(&self) -> &[Self::PointConcat] { &self.point_concats } fn opening_claims(&self) -> &[Self::OpeningClaim] { &self.opening_claims } fn opening_equalities(&self) -> &[Self::OpeningEquality] { &self.opening_equalities } fn opening_batches(&self) -> &[Self::OpeningBatch] { &self.opening_batches } @@ -1097,7 +1091,6 @@ macro_rules! impl_verifier_plan_source_traits { impl $crate::protocols::jolt::verifier_plan::VerifierPointSliceSource for $point_slice { fn symbol(&self) -> &str { &self.symbol } - fn source(&self) -> &str { &self.source } fn offset(&self) -> usize { self.offset } fn length(&self) -> usize { self.length } fn input(&self) -> &str { &self.input } @@ -1145,10 +1138,10 @@ macro_rules! impl_verifier_plan_source_traits { (@transcript_absorb_bytes $self:ident) => { Vec::new() }; - (@point_zeros $self:ident, $point_zero:ty) => { - $crate::protocols::jolt::verifier_plan::point_zeros_from_cpu(&$self.point_zeros) + (@point_zero_exprs $self:ident, $point_zero:ty) => { + $crate::protocols::jolt::verifier_plan::point_zero_exprs_from_cpu(&$self.point_zeros) }; - (@point_zeros $self:ident) => { + (@point_zero_exprs $self:ident) => { Vec::new() }; (@indexed_eval_families $self:ident, $indexed_eval_families:ident) => { @@ -1610,72 +1603,46 @@ pub(crate) fn emit_sumcheck_instance_result_constants( ) } -pub(crate) fn emit_point_slice_constants( - stage_type_prefix: &str, - const_prefix: &str, - slices: &[VerifierPointSlicePlan], -) -> String { - let slices = slices - .iter() - .map(|slice| { - format!( - " {stage_type_prefix}PointSlicePlan {{ symbol: {}, source: {}, offset: {}, length: {}, input: {} }},", - rust_str(&slice.symbol), - rust_str(&slice.source), - slice.offset, - slice.length, - rust_str(&slice.input) - ) - }) - .collect::>() - .join("\n"); - format!( - "pub const {const_prefix}_POINT_SLICES: &[{stage_type_prefix}PointSlicePlan] = &[\n{slices}\n];\n\n" - ) -} - -pub(crate) fn emit_point_zero_constants( +pub(crate) fn point_expr_kind_expr( stage_type_prefix: &str, - const_prefix: &str, - zeros: &[VerifierPointZeroPlan], + kind: &VerifierPointExprKind, ) -> String { - let zeros = zeros - .iter() - .map(|zero| { + match kind { + VerifierPointExprKind::Zero { field, arity } => format!( + "{stage_type_prefix}PointExprKind::Zero {{ field: {}, arity: {arity} }}", + rust_str(field) + ), + VerifierPointExprKind::Slice { offset, length } => { format!( - " {stage_type_prefix}PointZeroPlan {{ symbol: {}, field: {}, arity: {} }},", - rust_str(&zero.symbol), - rust_str(&zero.field), - zero.arity + "{stage_type_prefix}PointExprKind::Slice {{ offset: {offset}, length: {length} }}" ) - }) - .collect::>() - .join("\n"); - format!( - "pub const {const_prefix}_POINT_ZEROS: &[{stage_type_prefix}PointZeroPlan] = &[\n{zeros}\n];\n\n" - ) + } + VerifierPointExprKind::Concat { layout, arity } => format!( + "{stage_type_prefix}PointExprKind::Concat {{ layout: {}, arity: {arity} }}", + rust_str(layout) + ), + } } -pub(crate) fn emit_point_concat_constants( +pub(crate) fn emit_point_expr_constants( stage_type_prefix: &str, const_prefix: &str, - concats: &[VerifierPointConcatPlan], + exprs: &[VerifierPointExprPlan], ) -> String { - let concats = concats + let exprs = exprs .iter() - .map(|concat| { + .map(|expr| { format!( - " {stage_type_prefix}PointConcatPlan {{ symbol: {}, layout: {}, arity: {}, inputs: {} }},", - rust_str(&concat.symbol), - rust_str(&concat.layout), - concat.arity, - rust_str_slice_expr(&concat.inputs) + " {stage_type_prefix}PointExprPlan {{ symbol: {}, kind: {}, operands: {} }},", + rust_str(&expr.symbol), + point_expr_kind_expr(stage_type_prefix, &expr.kind), + rust_str_slice_expr(&expr.operands) ) }) .collect::>() .join("\n"); format!( - "pub const {const_prefix}_POINT_CONCATS: &[{stage_type_prefix}PointConcatPlan] = &[\n{concats}\n];\n" + "pub const {const_prefix}_POINT_EXPRS: &[{stage_type_prefix}PointExprPlan] = &[\n{exprs}\n];\n\n" ) } diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 14fe44309d..56ca5ae933 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -1832,7 +1832,7 @@ mod tests { let field_values = VerifierScalarSourceSet::default(); let mut point_values = VerifierPointSourceSet::default(); point_values.insert("point", VerifierPointSourceKind::OpeningInput); - point_values.insert("point", VerifierPointSourceKind::PointSlice); + point_values.insert("point", VerifierPointSourceKind::PointExpr); let relations = BTreeSet::new(); let error = match verify_relation_outputs( @@ -1857,7 +1857,7 @@ mod tests { }; assert!(error.to_string().contains( - "stage point source @point has conflicting kinds OpeningInput and PointSlice" + "stage point source @point has conflicting kinds OpeningInput and PointExpr" )); Ok(()) } diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 024876f19d..90da83c540 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -97,9 +97,7 @@ impl VerifierFieldVectorSourceSet { pub enum VerifierPointSourceKind { OpeningInput, SumcheckInstance, - PointZero, - PointSlice, - PointConcat, + PointExpr, } #[derive(Clone, Debug, Default, PartialEq, Eq)] diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 8fb1a20821..94f7e46f84 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -33,6 +33,46 @@ macro_rules! stage_scalar_expr { }; } +macro_rules! stage_generated_point_exprs { + ($module:ident, $point_expr:ident, $program:ident $(, point_zero = $point_zero:ident)?) => {{ + let mut exprs = Vec::new(); + $( + let _ = stringify!($point_zero); + exprs.extend($program.point_zeros.iter().map(|plan| { + $module::$point_expr { + symbol: super::leak_str(&plan.symbol), + kind: bolt_verifier_runtime::PointExprKind::Zero { + field: super::leak_str(&plan.field), + arity: plan.arity, + }, + operands: &[], + } + })); + )? + exprs.extend($program.point_slices.iter().map(|plan| { + $module::$point_expr { + symbol: super::leak_str(&plan.symbol), + kind: bolt_verifier_runtime::PointExprKind::Slice { + offset: plan.offset, + length: plan.length, + }, + operands: super::leak_str_slice(std::slice::from_ref(&plan.input)), + } + })); + exprs.extend($program.point_concats.iter().map(|plan| { + $module::$point_expr { + symbol: super::leak_str(&plan.symbol), + kind: bolt_verifier_runtime::PointExprKind::Concat { + layout: super::leak_str(&plan.layout), + arity: plan.arity, + }, + operands: super::leak_str_slice(&plan.inputs), + } + })); + super::leak_slice(exprs) + }}; +} + macro_rules! stage_optional_relation_kind { (kernel, $value:expr) => { $value.map(super::leak_str) @@ -534,8 +574,6 @@ macro_rules! define_stage_adapter_impl { $driver:ident, $instance_result:ident, $eval:ident, - $point_slice:ident, - $point_concat:ident, $opening_claim:ident, $opening_batch:ident $(, role = $role_field:ident)? @@ -543,7 +581,10 @@ macro_rules! define_stage_adapter_impl { $(, kernels = $kernel:ident)? $(, scalar_expr = $scalar_expr:ident)? $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? - $(, point_zeros = $point_zero:ident)? + $(, generated_points = $generated_point:ident)? + $(, generated_points_with_zeros = $generated_point_with_zeros:ident, $generated_point_zero:ident)? + $(, kernel_points = $kernel_point_slice:ident, $kernel_point_concat:ident)? + $(, kernel_points_with_zeros = $kernel_point_slice_with_zeros:ident, $kernel_point_concat_with_zeros:ident, $kernel_point_zero:ident)? $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? @@ -763,23 +804,64 @@ macro_rules! define_stage_adapter_impl { }, )? $( + point_exprs: stage_generated_point_exprs!( + $module, + $generated_point, + program + ), + )? + $( + point_exprs: stage_generated_point_exprs!( + $module, + $generated_point_with_zeros, + program, + point_zero = $generated_point_zero + ), + )? + $( + point_slices: super::leak_slice( + program + .point_slices + .iter() + .map(|plan| $module::$kernel_point_slice { + symbol: super::leak_str(&plan.symbol), + source: super::leak_str(&plan.source), + offset: plan.offset, + length: plan.length, + input: super::leak_str(&plan.input), + }) + .collect(), + ), + point_concats: super::leak_slice( + program + .point_concats + .iter() + .map(|plan| $module::$kernel_point_concat { + symbol: super::leak_str(&plan.symbol), + layout: super::leak_str(&plan.layout), + arity: plan.arity, + inputs: super::leak_str_slice(&plan.inputs), + }) + .collect(), + ), + )? + $( point_zeros: super::leak_slice( program .point_zeros .iter() - .map(|plan| $module::$point_zero { + .map(|plan| $module::$kernel_point_zero { symbol: super::leak_str(&plan.symbol), field: super::leak_str(&plan.field), arity: plan.arity, }) .collect(), ), - )? point_slices: super::leak_slice( program .point_slices .iter() - .map(|plan| $module::$point_slice { + .map(|plan| $module::$kernel_point_slice_with_zeros { symbol: super::leak_str(&plan.symbol), source: super::leak_str(&plan.source), offset: plan.offset, @@ -792,7 +874,7 @@ macro_rules! define_stage_adapter_impl { program .point_concats .iter() - .map(|plan| $module::$point_concat { + .map(|plan| $module::$kernel_point_concat_with_zeros { symbol: super::leak_str(&plan.symbol), layout: super::leak_str(&plan.layout), arity: plan.arity, @@ -800,6 +882,7 @@ macro_rules! define_stage_adapter_impl { }) .collect(), ), + )? opening_claims: super::leak_slice( program .opening_claims @@ -851,7 +934,192 @@ macro_rules! define_stage_adapter_impl { macro_rules! define_stage_adapter { ( - $mode:ident, + generated, + $function:ident, + $compiler:ty, + $module:ident, + $program:ident, + $params:ident, + $step:ident, + $squeeze:ident, + $absorb:ident, + $opening_input:ident, + $field_constant:ident, + $field_expr:ident, + $kernel:ident, + $claim:ident, + $batch:ident, + $driver:ident, + $instance_result:ident, + $eval:ident, + $point_expr:ident, + $point_concat:ident, + $opening_claim:ident, + $opening_equality:ident, + $opening_batch:ident, + point_zero = $point_zero:ident + $(, scalar_expr = $scalar_expr:ident)? + $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? + $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, empty_relation_outputs = $empty_relation_outputs:ident)? + ) => { + define_stage_adapter_impl!( + generated, + $function, + $compiler, + $module, + $program, + $params, + $step, + $squeeze, + $opening_input, + $field_constant, + $field_expr, + $claim, + $batch, + $driver, + $instance_result, + $eval, + $opening_claim, + $opening_batch, + role = role, + transcript_absorb_bytes = $absorb, + kernels = $kernel + $(, scalar_expr = $scalar_expr)? + $(, empty_scalar_exprs = $empty_scalar_exprs)? + , + generated_points_with_zeros = $point_expr, $point_zero + $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, empty_relation_outputs = $empty_relation_outputs)? + , + opening_equalities = $opening_equality + ); + }; + ( + generated, + $function:ident, + $compiler:ty, + $module:ident, + $program:ident, + $params:ident, + $step:ident, + $squeeze:ident, + $absorb:ident, + $opening_input:ident, + $field_constant:ident, + $field_expr:ident, + $kernel:ident, + $claim:ident, + $batch:ident, + $driver:ident, + $instance_result:ident, + $eval:ident, + $point_expr:ident, + $point_concat:ident, + $opening_claim:ident, + $opening_equality:ident, + $opening_batch:ident + $(, scalar_expr = $scalar_expr:ident)? + $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? + $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, empty_relation_outputs = $empty_relation_outputs:ident)? + ) => { + define_stage_adapter_impl!( + generated, + $function, + $compiler, + $module, + $program, + $params, + $step, + $squeeze, + $opening_input, + $field_constant, + $field_expr, + $claim, + $batch, + $driver, + $instance_result, + $eval, + $opening_claim, + $opening_batch, + role = role, + transcript_absorb_bytes = $absorb, + kernels = $kernel + $(, scalar_expr = $scalar_expr)? + $(, empty_scalar_exprs = $empty_scalar_exprs)? + , + generated_points = $point_expr + $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, empty_relation_outputs = $empty_relation_outputs)? + , + opening_equalities = $opening_equality + ); + }; + ( + kernel, + $function:ident, + $compiler:ty, + $module:ident, + $program:ident, + $params:ident, + $step:ident, + $squeeze:ident, + $absorb:ident, + $opening_input:ident, + $field_constant:ident, + $field_expr:ident, + $kernel:ident, + $claim:ident, + $batch:ident, + $driver:ident, + $instance_result:ident, + $eval:ident, + $point_slice:ident, + $point_concat:ident, + $opening_claim:ident, + $opening_equality:ident, + $opening_batch:ident, + point_zero = $point_zero:ident + $(, scalar_expr = $scalar_expr:ident)? + $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? + $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, empty_relation_outputs = $empty_relation_outputs:ident)? + ) => { + define_stage_adapter_impl!( + kernel, + $function, + $compiler, + $module, + $program, + $params, + $step, + $squeeze, + $opening_input, + $field_constant, + $field_expr, + $claim, + $batch, + $driver, + $instance_result, + $eval, + $opening_claim, + $opening_batch, + role = role, + transcript_absorb_bytes = $absorb, + kernels = $kernel + $(, scalar_expr = $scalar_expr)? + $(, empty_scalar_exprs = $empty_scalar_exprs)? + , + kernel_points_with_zeros = $point_slice, $point_concat, $point_zero + $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, empty_relation_outputs = $empty_relation_outputs)? + , + opening_equalities = $opening_equality + ); + }; + ( + kernel, $function:ident, $compiler:ty, $module:ident, @@ -874,14 +1142,13 @@ macro_rules! define_stage_adapter { $opening_claim:ident, $opening_equality:ident, $opening_batch:ident - $(, point_zero = $point_zero:ident)? $(, scalar_expr = $scalar_expr:ident)? $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? ) => { define_stage_adapter_impl!( - $mode, + kernel, $function, $compiler, $module, @@ -897,8 +1164,6 @@ macro_rules! define_stage_adapter { $driver, $instance_result, $eval, - $point_slice, - $point_concat, $opening_claim, $opening_batch, role = role, @@ -906,7 +1171,8 @@ macro_rules! define_stage_adapter { kernels = $kernel $(, scalar_expr = $scalar_expr)? $(, empty_scalar_exprs = $empty_scalar_exprs)? - $(, point_zeros = $point_zero)? + , + kernel_points = $point_slice, $point_concat $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? $(, empty_relation_outputs = $empty_relation_outputs)? , @@ -917,7 +1183,64 @@ macro_rules! define_stage_adapter { macro_rules! define_stage_adapter_no_absorb { ( - $mode:ident, + generated, + $function:ident, + $compiler:ty, + $module:ident, + $program:ident, + $params:ident, + $step:ident, + $squeeze:ident, + $opening_input:ident, + $field_constant:ident, + $field_expr:ident, + $claim:ident, + $batch:ident, + $driver:ident, + $instance_result:ident, + $eval:ident, + $point_expr:ident, + $point_concat:ident, + $opening_claim:ident, + $opening_batch:ident + $(, kernels = $kernel:ident)? + $(, scalar_expr = $scalar_expr:ident)? + $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? + $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, empty_relation_outputs = $empty_relation_outputs:ident)? + $(, opening_equalities = $opening_equality:ident)? + ) => { + define_stage_adapter_impl!( + generated, + $function, + $compiler, + $module, + $program, + $params, + $step, + $squeeze, + $opening_input, + $field_constant, + $field_expr, + $claim, + $batch, + $driver, + $instance_result, + $eval, + $opening_claim, + $opening_batch + $(, kernels = $kernel)? + $(, scalar_expr = $scalar_expr)? + $(, empty_scalar_exprs = $empty_scalar_exprs)? + , + generated_points = $point_expr + $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, empty_relation_outputs = $empty_relation_outputs)? + $(, opening_equalities = $opening_equality)? + ); + }; + ( + kernel, $function:ident, $compiler:ty, $module:ident, @@ -945,7 +1268,7 @@ macro_rules! define_stage_adapter_no_absorb { $(, opening_equalities = $opening_equality:ident)? ) => { define_stage_adapter_impl!( - $mode, + kernel, $function, $compiler, $module, @@ -961,13 +1284,13 @@ macro_rules! define_stage_adapter_no_absorb { $driver, $instance_result, $eval, - $point_slice, - $point_concat, $opening_claim, $opening_batch $(, kernels = $kernel)? $(, scalar_expr = $scalar_expr)? $(, empty_scalar_exprs = $empty_scalar_exprs)? + , + kernel_points = $point_slice, $point_concat $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? $(, empty_relation_outputs = $empty_relation_outputs)? $(, opening_equalities = $opening_equality)? diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs index fe3d348673..c5426e57f4 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs @@ -18,8 +18,8 @@ define_stage_adapter_no_absorb!( Stage2SumcheckDriverPlan, Stage2SumcheckInstanceResultPlan, Stage2SumcheckEvalPlan, - Stage2PointSlicePlan, - Stage2PointConcatPlan, + Stage2PointExprPlan, + Stage2PointExprPlan, Stage2OpeningClaimPlan, Stage2OpeningBatchPlan, empty_scalar_exprs = Stage2ScalarExprPlan diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs index f72f28d4bb..2fd160638f 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs @@ -18,8 +18,8 @@ define_stage_adapter_no_absorb!( Stage3SumcheckDriverPlan, Stage3SumcheckInstanceResultPlan, Stage3SumcheckEvalPlan, - Stage3PointSlicePlan, - Stage3PointConcatPlan, + Stage3PointExprPlan, + Stage3PointExprPlan, Stage3OpeningClaimPlan, Stage3OpeningBatchPlan, scalar_expr = Stage3ScalarExprPlan, diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs index 8d4328b1b4..b79c998c68 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs @@ -20,8 +20,8 @@ define_stage_adapter!( Stage4SumcheckDriverPlan, Stage4SumcheckInstanceResultPlan, Stage4SumcheckEvalPlan, - Stage4PointSlicePlan, - Stage4PointConcatPlan, + Stage4PointExprPlan, + Stage4PointExprPlan, Stage4OpeningClaimPlan, Stage4OpeningClaimEqualityPlan, Stage4OpeningBatchPlan, diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs index fa7f0b6877..6db160d3e7 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs @@ -20,8 +20,8 @@ define_stage_adapter!( Stage5SumcheckDriverPlan, Stage5SumcheckInstanceResultPlan, Stage5SumcheckEvalPlan, - Stage5PointSlicePlan, - Stage5PointConcatPlan, + Stage5PointExprPlan, + Stage5PointExprPlan, Stage5OpeningClaimPlan, Stage5OpeningClaimEqualityPlan, Stage5OpeningBatchPlan, diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs index e33b720390..a755f2ade6 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs @@ -20,12 +20,12 @@ define_stage_adapter!( Stage6SumcheckDriverPlan, Stage6SumcheckInstanceResultPlan, Stage6SumcheckEvalPlan, - Stage6PointSlicePlan, - Stage6PointConcatPlan, + Stage6PointExprPlan, + Stage6PointExprPlan, Stage6OpeningClaimPlan, Stage6OpeningClaimEqualityPlan, Stage6OpeningBatchPlan, - point_zero = Stage6PointZeroPlan, + point_zero = Stage6PointExprPlan, scalar_expr = Stage6ScalarExprPlan, relation_outputs = Stage6RelationOutputPlan, relation_output_values = Stage6StructuredPolynomialEvalPlan diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs index e4569b630d..d16fdd2463 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs @@ -20,12 +20,12 @@ define_stage_adapter!( Stage7SumcheckDriverPlan, Stage7SumcheckInstanceResultPlan, Stage7SumcheckEvalPlan, - Stage7PointSlicePlan, - Stage7PointConcatPlan, + Stage7PointExprPlan, + Stage7PointExprPlan, Stage7OpeningClaimPlan, Stage7OpeningClaimEqualityPlan, Stage7OpeningBatchPlan, - point_zero = Stage7PointZeroPlan, + point_zero = Stage7PointExprPlan, scalar_expr = Stage7ScalarExprPlan, relation_outputs = Stage7RelationOutputPlan, relation_output_values = Stage7StructuredPolynomialEvalPlan diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index a90bd21389..a125f580e8 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -27,8 +27,8 @@ pub use bolt_verifier_runtime::{ FieldExprPlan as Stage2FieldExprPlan, ScalarExprPlan as Stage2ScalarExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, - OpeningInputPlan as Stage2OpeningInputPlan, PointConcatPlan as Stage2PointConcatPlan, - PointSlicePlan as Stage2PointSlicePlan, ProgramStepKind as Stage2ProgramStepKind, + OpeningInputPlan as Stage2OpeningInputPlan, PointExprKind as Stage2PointExprKind, + PointExprPlan as Stage2PointExprPlan, ProgramStepKind as Stage2ProgramStepKind, ProgramStepPlan as Stage2ProgramStepPlan, StageParams as Stage2Params, SumcheckBatchPlan as Stage2SumcheckBatchPlan, SumcheckEvalPlan as Stage2SumcheckEvalPlan, @@ -201,13 +201,11 @@ pub const STAGE2_SUMCHECK_EVALS: &[Stage2SumcheckEvalPlan] = &[ Stage2SumcheckEvalPlan { symbol: "stage2.ram_output.eval.RamValFinal", source: "stage2.sumcheck", name: "stage2.ram_output.eval.RamValFinal", index: 0, oracle: "RamValFinal" }, ]; -pub const STAGE2_POINT_SLICES: &[Stage2PointSlicePlan] = &[ - Stage2PointSlicePlan { symbol: "stage2.ram_read_write.point.RamInc", source: "stage2.ram_read_write.instance", offset: 16, length: 16, input: "stage2.ram_read_write.instance" }, +pub const STAGE2_POINT_EXPRS: &[Stage2PointExprPlan] = &[ + Stage2PointExprPlan { symbol: "stage2.ram_read_write.point.RamInc", kind: Stage2PointExprKind::Slice { offset: 16, length: 16 }, operands: &["stage2.ram_read_write.instance"] }, + Stage2PointExprPlan { symbol: "stage2.ram_raf.point.RamRa", kind: Stage2PointExprKind::Concat { layout: "address_then_cycle", arity: 32 }, operands: &["stage2.ram_raf.instance", "stage2.input.stage1.RamAddress"] }, ]; -pub const STAGE2_POINT_CONCATS: &[Stage2PointConcatPlan] = &[ - Stage2PointConcatPlan { symbol: "stage2.ram_raf.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: &["stage2.ram_raf.instance", "stage2.input.stage1.RamAddress"] }, -]; pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[ Stage2OpeningClaimPlan { symbol: "stage2.product_virtual.uniskip.opening.UnivariateSkip", oracle: "UnivariateSkip", domain: "jolt.stage2_uniskip_domain", point_arity: 1, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.product_virtual.uniskip.instance", eval_source: "stage2.product_virtual.uniskip.eval.UnivariateSkip" }, Stage2OpeningClaimPlan { symbol: "stage2.ram_read_write.opening.RamVal", oracle: "RamVal", domain: "jolt.stage2_ram_rw_domain", point_arity: 32, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.ram_read_write.instance", eval_source: "stage2.ram_read_write.eval.RamVal" }, @@ -254,8 +252,7 @@ pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan drivers: STAGE2_SUMCHECK_DRIVERS, instance_results: STAGE2_SUMCHECK_INSTANCE_RESULTS, evals: STAGE2_SUMCHECK_EVALS, - point_slices: STAGE2_POINT_SLICES, - point_concats: STAGE2_POINT_CONCATS, + point_exprs: STAGE2_POINT_EXPRS, opening_claims: STAGE2_OPENING_CLAIMS, opening_batches: STAGE2_OPENING_BATCHES, }; @@ -626,8 +623,7 @@ impl Stage2ValueStore { program: &'static Stage2VerifierProgramPlan, ) -> Result<(), VerifyStage2Error> { self.0.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage2Error::InvalidInputLength { input, expected, diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index baaedb771e..325f87b092 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -30,7 +30,7 @@ pub use bolt_verifier_runtime::{ OpeningBatchPlan as Stage3OpeningBatchPlan, OpeningClaimEqualityPlan as Stage3OpeningClaimEqualityPlan, OpeningClaimPlan as Stage3OpeningClaimPlan, OpeningInputPlan as Stage3OpeningInputPlan, - PointConcatPlan as Stage3PointConcatPlan, PointSlicePlan as Stage3PointSlicePlan, + PointExprKind as Stage3PointExprKind, PointExprPlan as Stage3PointExprPlan, OpeningEqualityMode as Stage3OpeningEqualityMode, ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, @@ -184,13 +184,10 @@ pub const STAGE3_SUMCHECK_EVALS: &[Stage3SumcheckEvalPlan] = &[ Stage3SumcheckEvalPlan { symbol: "stage3.registers_claim_reduction.eval.Rs2Value", source: "stage3.sumcheck", name: "stage3.registers_claim_reduction.eval.Rs2Value", index: 15, oracle: "Rs2Value" }, ]; -pub const STAGE3_POINT_SLICES: &[Stage3PointSlicePlan] = &[ +pub const STAGE3_POINT_EXPRS: &[Stage3PointExprPlan] = &[ ]; -pub const STAGE3_POINT_CONCATS: &[Stage3PointConcatPlan] = &[ - -]; pub const STAGE3_OPENING_CLAIMS: &[Stage3OpeningClaimPlan] = &[ Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.UnexpandedPC", oracle: "UnexpandedPC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.UnexpandedPC" }, Stage3OpeningClaimPlan { symbol: "stage3.spartan_shift.opening.PC", oracle: "PC", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage3ClaimKind::Virtual, point_source: "stage3.spartan_shift.instance", eval_source: "stage3.spartan_shift.eval.PC" }, @@ -246,8 +243,7 @@ pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan evals: STAGE3_SUMCHECK_EVALS, relation_output_values: STAGE3_RELATION_OUTPUT_VALUES, relation_outputs: STAGE3_RELATION_OUTPUTS, - point_slices: STAGE3_POINT_SLICES, - point_concats: STAGE3_POINT_CONCATS, + point_exprs: STAGE3_POINT_EXPRS, opening_claims: STAGE3_OPENING_CLAIMS, opening_equalities: STAGE3_OPENING_EQUALITIES, opening_batches: STAGE3_OPENING_BATCHES, @@ -389,8 +385,7 @@ where T: Transcript, { store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage3Error::InvalidInputLength { input, expected, @@ -447,8 +442,7 @@ fn observe_stage3_sumcheck_output( |symbol| VerifyStage3Error::MissingValue { symbol }, )?; store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage3Error::InvalidInputLength { input, expected, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 7ba1940bbf..1ef6f51d97 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -11,7 +11,7 @@ pub type Stage4ChallengeVector = bolt_verifier_runtime::StageChallengeVector< pub type Stage4ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; pub type Stage4Proof = bolt_verifier_runtime::StageProof; pub type Stage4OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; -pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZeros; +pub type Stage4CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage4SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; @@ -28,8 +28,8 @@ pub use bolt_verifier_runtime::{ KernelPlan as Stage4KernelPlan, OpeningBatchPlan as Stage4OpeningBatchPlan, OpeningClaimEqualityPlan as Stage4OpeningClaimEqualityPlan, OpeningClaimPlan as Stage4OpeningClaimPlan, OpeningInputPlan as Stage4OpeningInputPlan, - OpeningEqualityMode as Stage4OpeningEqualityMode, - PointConcatPlan as Stage4PointConcatPlan, PointSlicePlan as Stage4PointSlicePlan, + OpeningEqualityMode as Stage4OpeningEqualityMode, PointExprKind as Stage4PointExprKind, + PointExprPlan as Stage4PointExprPlan, ProgramStepKind as Stage4ProgramStepKind, ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, SumcheckBatchPlan as Stage4SumcheckBatchPlan, @@ -154,14 +154,12 @@ pub const STAGE4_SUMCHECK_EVALS: &[Stage4SumcheckEvalPlan] = &[ Stage4SumcheckEvalPlan { symbol: "stage4.ram_val_check.eval.RamInc", source: "stage4.sumcheck", name: "stage4.ram_val_check.eval.RamInc", index: 1, oracle: "RamInc" }, ]; -pub const STAGE4_POINT_SLICES: &[Stage4PointSlicePlan] = &[ - Stage4PointSlicePlan { symbol: "stage4.registers_read_write.point.RdInc", source: "stage4.registers_read_write.instance", offset: 7, length: 16, input: "stage4.registers_read_write.instance" }, - Stage4PointSlicePlan { symbol: "stage4.ram_val_check.point.RamAddress", source: "stage4.input.stage2.RamVal", offset: 0, length: 16, input: "stage4.input.stage2.RamVal" }, +pub const STAGE4_POINT_EXPRS: &[Stage4PointExprPlan] = &[ + Stage4PointExprPlan { symbol: "stage4.registers_read_write.point.RdInc", kind: Stage4PointExprKind::Slice { offset: 7, length: 16 }, operands: &["stage4.registers_read_write.instance"] }, + Stage4PointExprPlan { symbol: "stage4.ram_val_check.point.RamAddress", kind: Stage4PointExprKind::Slice { offset: 0, length: 16 }, operands: &["stage4.input.stage2.RamVal"] }, + Stage4PointExprPlan { symbol: "stage4.ram_val_check.point.RamRa", kind: Stage4PointExprKind::Concat { layout: "address_then_cycle", arity: 32 }, operands: &["stage4.ram_val_check.point.RamAddress", "stage4.ram_val_check.instance"] }, ]; -pub const STAGE4_POINT_CONCATS: &[Stage4PointConcatPlan] = &[ - Stage4PointConcatPlan { symbol: "stage4.ram_val_check.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: &["stage4.ram_val_check.point.RamAddress", "stage4.ram_val_check.instance"] }, -]; pub const STAGE4_OPENING_CLAIMS: &[Stage4OpeningClaimPlan] = &[ Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.RegistersVal", oracle: "RegistersVal", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.RegistersVal" }, Stage4OpeningClaimPlan { symbol: "stage4.registers_read_write.opening.Rs1Ra", oracle: "Rs1Ra", domain: "jolt.stage4_registers_rw_domain", point_arity: 23, claim_kind: Stage4ClaimKind::Virtual, point_source: "stage4.registers_read_write.instance", eval_source: "stage4.registers_read_write.eval.Rs1Ra" }, @@ -208,8 +206,7 @@ pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { evals: STAGE4_SUMCHECK_EVALS, relation_output_values: STAGE4_RELATION_OUTPUT_VALUES, relation_outputs: STAGE4_RELATION_OUTPUTS, - point_slices: STAGE4_POINT_SLICES, - point_concats: STAGE4_POINT_CONCATS, + point_exprs: STAGE4_POINT_EXPRS, opening_claims: STAGE4_OPENING_CLAIMS, opening_equalities: STAGE4_OPENING_EQUALITIES, opening_batches: STAGE4_OPENING_BATCHES, @@ -364,8 +361,7 @@ where T: Transcript, { store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage4Error::InvalidInputLength { input, expected, @@ -425,8 +421,7 @@ fn observe_stage4_sumcheck_output( |symbol| VerifyStage4Error::MissingValue { symbol }, )?; store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage4Error::InvalidInputLength { input, expected, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 63e5c1188a..d446b13c01 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -12,7 +12,7 @@ pub type Stage5ChallengeVector = bolt_verifier_runtime::StageChallengeVector< pub type Stage5ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; pub type Stage5Proof = bolt_verifier_runtime::StageProof; pub type Stage5OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; -pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlanNoPointZeros; +pub type Stage5CpuProgramPlan = bolt_verifier_runtime::StageProgramPlan; pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage5SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; @@ -29,8 +29,8 @@ pub use bolt_verifier_runtime::{ KernelPlan as Stage5KernelPlan, OpeningBatchPlan as Stage5OpeningBatchPlan, OpeningClaimEqualityPlan as Stage5OpeningClaimEqualityPlan, OpeningClaimPlan as Stage5OpeningClaimPlan, OpeningInputPlan as Stage5OpeningInputPlan, - OpeningEqualityMode as Stage5OpeningEqualityMode, - PointConcatPlan as Stage5PointConcatPlan, PointSlicePlan as Stage5PointSlicePlan, + OpeningEqualityMode as Stage5OpeningEqualityMode, PointExprKind as Stage5PointExprKind, + PointExprPlan as Stage5PointExprPlan, ProgramStepKind as Stage5ProgramStepKind, ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params, SumcheckBatchPlan as Stage5SumcheckBatchPlan, @@ -313,32 +313,30 @@ pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage log_k: 128, }; -pub const STAGE5_POINT_SLICES: &[Stage5PointSlicePlan] = &[ - Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.Cycle", source: "stage5.instruction_read_raf.instance", offset: 128, length: 16, input: "stage5.instruction_read_raf.instance" }, - Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0.address", source: "stage5.instruction_read_raf.instance", offset: 0, length: 16, input: "stage5.instruction_read_raf.instance" }, - Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_1.address", source: "stage5.instruction_read_raf.instance", offset: 16, length: 16, input: "stage5.instruction_read_raf.instance" }, - Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_2.address", source: "stage5.instruction_read_raf.instance", offset: 32, length: 16, input: "stage5.instruction_read_raf.instance" }, - Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_3.address", source: "stage5.instruction_read_raf.instance", offset: 48, length: 16, input: "stage5.instruction_read_raf.instance" }, - Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_4.address", source: "stage5.instruction_read_raf.instance", offset: 64, length: 16, input: "stage5.instruction_read_raf.instance" }, - Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_5.address", source: "stage5.instruction_read_raf.instance", offset: 80, length: 16, input: "stage5.instruction_read_raf.instance" }, - Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_6.address", source: "stage5.instruction_read_raf.instance", offset: 96, length: 16, input: "stage5.instruction_read_raf.instance" }, - Stage5PointSlicePlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_7.address", source: "stage5.instruction_read_raf.instance", offset: 112, length: 16, input: "stage5.instruction_read_raf.instance" }, - Stage5PointSlicePlan { symbol: "stage5.ram_ra_claim_reduction.point.RamAddress", source: "stage5.input.stage2.ram_raf.RamRa", offset: 0, length: 16, input: "stage5.input.stage2.ram_raf.RamRa" }, - Stage5PointSlicePlan { symbol: "stage5.registers_val_evaluation.point.RegisterAddress", source: "stage5.input.stage4.registers.RegistersVal", offset: 0, length: 7, input: "stage5.input.stage4.registers.RegistersVal" }, +pub const STAGE5_POINT_EXPRS: &[Stage5PointExprPlan] = &[ + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.Cycle", kind: Stage5PointExprKind::Slice { offset: 128, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0.address", kind: Stage5PointExprKind::Slice { offset: 0, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_1.address", kind: Stage5PointExprKind::Slice { offset: 16, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_2.address", kind: Stage5PointExprKind::Slice { offset: 32, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_3.address", kind: Stage5PointExprKind::Slice { offset: 48, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_4.address", kind: Stage5PointExprKind::Slice { offset: 64, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_5.address", kind: Stage5PointExprKind::Slice { offset: 80, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_6.address", kind: Stage5PointExprKind::Slice { offset: 96, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_7.address", kind: Stage5PointExprKind::Slice { offset: 112, length: 16 }, operands: &["stage5.instruction_read_raf.instance"] }, + Stage5PointExprPlan { symbol: "stage5.ram_ra_claim_reduction.point.RamAddress", kind: Stage5PointExprKind::Slice { offset: 0, length: 16 }, operands: &["stage5.input.stage2.ram_raf.RamRa"] }, + Stage5PointExprPlan { symbol: "stage5.registers_val_evaluation.point.RegisterAddress", kind: Stage5PointExprKind::Slice { offset: 0, length: 7 }, operands: &["stage5.input.stage4.registers.RegistersVal"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_0.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_1", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_1.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_2", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_2.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_3", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_3.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_4", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_4.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_5", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_5.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_6", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_6.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointExprPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_7", kind: Stage5PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 32 }, operands: &["stage5.instruction_read_raf.point.InstructionRa_7.address", "stage5.instruction_read_raf.point.Cycle"] }, + Stage5PointExprPlan { symbol: "stage5.ram_ra_claim_reduction.point.RamRa", kind: Stage5PointExprKind::Concat { layout: "address_then_cycle", arity: 32 }, operands: &["stage5.ram_ra_claim_reduction.point.RamAddress", "stage5.ram_ra_claim_reduction.instance"] }, + Stage5PointExprPlan { symbol: "stage5.registers_val_evaluation.point.RdWa", kind: Stage5PointExprKind::Concat { layout: "register_address_then_cycle", arity: 23 }, operands: &["stage5.registers_val_evaluation.point.RegisterAddress", "stage5.registers_val_evaluation.instance"] }, ]; -pub const STAGE5_POINT_CONCATS: &[Stage5PointConcatPlan] = &[ - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_0", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_0.address", "stage5.instruction_read_raf.point.Cycle"] }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_1", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_1.address", "stage5.instruction_read_raf.point.Cycle"] }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_2", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_2.address", "stage5.instruction_read_raf.point.Cycle"] }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_3", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_3.address", "stage5.instruction_read_raf.point.Cycle"] }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_4", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_4.address", "stage5.instruction_read_raf.point.Cycle"] }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_5", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_5.address", "stage5.instruction_read_raf.point.Cycle"] }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_6", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_6.address", "stage5.instruction_read_raf.point.Cycle"] }, - Stage5PointConcatPlan { symbol: "stage5.instruction_read_raf.point.InstructionRa_7", layout: "address_chunk_then_cycle", arity: 32, inputs: &["stage5.instruction_read_raf.point.InstructionRa_7.address", "stage5.instruction_read_raf.point.Cycle"] }, - Stage5PointConcatPlan { symbol: "stage5.ram_ra_claim_reduction.point.RamRa", layout: "address_then_cycle", arity: 32, inputs: &["stage5.ram_ra_claim_reduction.point.RamAddress", "stage5.ram_ra_claim_reduction.instance"] }, - Stage5PointConcatPlan { symbol: "stage5.registers_val_evaluation.point.RdWa", layout: "register_address_then_cycle", arity: 23, inputs: &["stage5.registers_val_evaluation.point.RegisterAddress", "stage5.registers_val_evaluation.instance"] }, -]; pub const STAGE5_OPENING_CLAIMS: &[Stage5OpeningClaimPlan] = &[ Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_0", oracle: "LookupTableFlag_0", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_0" }, Stage5OpeningClaimPlan { symbol: "stage5.instruction_read_raf.opening.LookupTableFlag_1", oracle: "LookupTableFlag_1", domain: "jolt.trace_domain", point_arity: 16, claim_kind: Stage5ClaimKind::Virtual, point_source: "stage5.instruction_read_raf.point.Cycle", eval_source: "stage5.instruction_read_raf.eval.LookupTableFlag_1" }, @@ -444,8 +442,7 @@ pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { evals: STAGE5_SUMCHECK_EVALS, relation_output_values: STAGE5_RELATION_OUTPUT_VALUES, relation_outputs: STAGE5_RELATION_OUTPUTS, - point_slices: STAGE5_POINT_SLICES, - point_concats: STAGE5_POINT_CONCATS, + point_exprs: STAGE5_POINT_EXPRS, opening_claims: STAGE5_OPENING_CLAIMS, opening_equalities: STAGE5_OPENING_EQUALITIES, opening_batches: STAGE5_OPENING_BATCHES, @@ -600,8 +597,7 @@ where T: Transcript, { store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage5Error::InvalidInputLength { input, expected, @@ -662,8 +658,7 @@ fn observe_stage5_sumcheck_output( )?; store.evaluate_named_eval_families(STAGE5_INDEXED_EVAL_FAMILIES)?; store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage5Error::InvalidInputLength { input, expected, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index d0b6940719..4a95a8810f 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -29,9 +29,8 @@ pub use bolt_verifier_runtime::{ KernelPlan as Stage6KernelPlan, OpeningBatchPlan as Stage6OpeningBatchPlan, OpeningClaimEqualityPlan as Stage6OpeningClaimEqualityPlan, OpeningClaimPlan as Stage6OpeningClaimPlan, OpeningInputPlan as Stage6OpeningInputPlan, - OpeningEqualityMode as Stage6OpeningEqualityMode, - PointConcatPlan as Stage6PointConcatPlan, PointSlicePlan as Stage6PointSlicePlan, - PointZeroPlan as Stage6PointZeroPlan, ProgramStepKind as Stage6ProgramStepKind, + OpeningEqualityMode as Stage6OpeningEqualityMode, PointExprKind as Stage6PointExprKind, + PointExprPlan as Stage6PointExprPlan, ProgramStepKind as Stage6ProgramStepKind, ProgramStepPlan as Stage6ProgramStepPlan, StageParams as Stage6Params, SumcheckBatchPlan as Stage6SumcheckBatchPlan, @@ -398,98 +397,93 @@ pub const STAGE6_SUMCHECK_EVALS: &[Stage6SumcheckEvalPlan] = &[ stage6_sumcheck_eval("stage6.inc_claim_reduction.eval.RdInc", "stage6.sumcheck", "stage6.inc_claim_reduction.eval.RdInc", 1, "RdInc"), ]; -pub const STAGE6_POINT_ZEROS: &[Stage6PointZeroPlan] = &[ - Stage6PointZeroPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address.zero_pad", field: "bn254_fr", arity: 2 }, +pub const STAGE6_POINT_EXPRS: &[Stage6PointExprPlan] = &[ + Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address.zero_pad", kind: Stage6PointExprKind::Zero { field: "bn254_fr", arity: 2 }, operands: &[] }, + Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.Cycle", kind: Stage6PointExprKind::Slice { offset: 10, length: 16 }, operands: &["stage6.bytecode_read_raf.instance"] }, + Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address.source", kind: Stage6PointExprKind::Slice { offset: 0, length: 2 }, operands: &["stage6.bytecode_read_raf.instance"] }, + Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_1.address", kind: Stage6PointExprKind::Slice { offset: 2, length: 4 }, operands: &["stage6.bytecode_read_raf.instance"] }, + Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_2.address", kind: Stage6PointExprKind::Slice { offset: 6, length: 4 }, operands: &["stage6.bytecode_read_raf.instance"] }, + Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_0.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.ram_ra_claim_reduction.RamRa"] }, + Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_1.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.ram_ra_claim_reduction.RamRa"] }, + Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_2.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.ram_ra_claim_reduction.RamRa"] }, + Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_3.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.ram_ra_claim_reduction.RamRa"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_0.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_1.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_2.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_3.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_4.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_1"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_5.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_1"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_6.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_1"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_7.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_1"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_8.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_2"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_9.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_2"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_10.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_2"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_11.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_2"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_12.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_3"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_13.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_3"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_14.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_3"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_15.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_3"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_16.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_4"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_17.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_4"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_18.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_4"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_19.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_4"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_20.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_5"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_21.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_5"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_22.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_5"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_23.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_5"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_24.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_6"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_25.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_6"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_26.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_6"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_27.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_6"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_28.address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_7"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29.address", kind: Stage6PointExprKind::Slice { offset: 4, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_7"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30.address", kind: Stage6PointExprKind::Slice { offset: 8, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_7"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31.address", kind: Stage6PointExprKind::Slice { offset: 12, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_7"] }, + Stage6PointExprPlan { symbol: "stage6.booleanity.output.point.Address", kind: Stage6PointExprKind::Slice { offset: 0, length: 4 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] }, + Stage6PointExprPlan { symbol: "stage6.booleanity.output.point.Cycle", kind: Stage6PointExprKind::Slice { offset: 16, length: 16 }, operands: &["stage6.input.stage5.instruction_read_raf.InstructionRa_0"] }, + Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address", kind: Stage6PointExprKind::Concat { layout: "left_zero_padded_address_chunk", arity: 4 }, operands: &["stage6.bytecode_read_raf.point.BytecodeRa_0.address.zero_pad", "stage6.bytecode_read_raf.point.BytecodeRa_0.address.source"] }, + Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.bytecode_read_raf.point.BytecodeRa_0.address", "stage6.bytecode_read_raf.point.Cycle"] }, + Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_1", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.bytecode_read_raf.point.BytecodeRa_1.address", "stage6.bytecode_read_raf.point.Cycle"] }, + Stage6PointExprPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_2", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.bytecode_read_raf.point.BytecodeRa_2.address", "stage6.bytecode_read_raf.point.Cycle"] }, + Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_0", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.ram_ra_virtual.point.RamRa_0.address", "stage6.ram_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_1", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.ram_ra_virtual.point.RamRa_1.address", "stage6.ram_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_2", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.ram_ra_virtual.point.RamRa_2.address", "stage6.ram_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_3", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.ram_ra_virtual.point.RamRa_3.address", "stage6.ram_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_0", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_0.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_1", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_1.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_2", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_2.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_3", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_3.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_4", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_4.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_5", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_5.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_6", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_6.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_7", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_7.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_8", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_8.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_9", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_9.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_10", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_10.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_11", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_11.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_12", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_12.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_13", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_13.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_14", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_14.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_15", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_15.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_16", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_16.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_17", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_17.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_18", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_18.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_19", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_19.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_20", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_20.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_21", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_21.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_22", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_22.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_23", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_23.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_24", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_24.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_25", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_25.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_26", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_26.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_27", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_27.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_28", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_28.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_29.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_30.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31", kind: Stage6PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage6.instruction_ra_virtual.point.InstructionRa_31.address", "stage6.instruction_ra_virtual.instance"] }, + Stage6PointExprPlan { symbol: "stage6.booleanity.output.point", kind: Stage6PointExprKind::Concat { layout: "address_prefix_then_cycle", arity: 20 }, operands: &["stage6.booleanity.output.point.Address", "stage6.booleanity.output.point.Cycle"] }, ]; -pub const STAGE6_POINT_SLICES: &[Stage6PointSlicePlan] = &[ - Stage6PointSlicePlan { symbol: "stage6.bytecode_read_raf.point.Cycle", source: "stage6.bytecode_read_raf.instance", offset: 10, length: 16, input: "stage6.bytecode_read_raf.instance" }, - Stage6PointSlicePlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address.source", source: "stage6.bytecode_read_raf.instance", offset: 0, length: 2, input: "stage6.bytecode_read_raf.instance" }, - Stage6PointSlicePlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_1.address", source: "stage6.bytecode_read_raf.instance", offset: 2, length: 4, input: "stage6.bytecode_read_raf.instance" }, - Stage6PointSlicePlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_2.address", source: "stage6.bytecode_read_raf.instance", offset: 6, length: 4, input: "stage6.bytecode_read_raf.instance" }, - Stage6PointSlicePlan { symbol: "stage6.ram_ra_virtual.point.RamRa_0.address", source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", offset: 0, length: 4, input: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" }, - Stage6PointSlicePlan { symbol: "stage6.ram_ra_virtual.point.RamRa_1.address", source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", offset: 4, length: 4, input: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" }, - Stage6PointSlicePlan { symbol: "stage6.ram_ra_virtual.point.RamRa_2.address", source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", offset: 8, length: 4, input: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" }, - Stage6PointSlicePlan { symbol: "stage6.ram_ra_virtual.point.RamRa_3.address", source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", offset: 12, length: 4, input: "stage6.input.stage5.ram_ra_claim_reduction.RamRa" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_0.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_1.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_2.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_3.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_4.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_1" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_5.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_1" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_6.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_1" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_7.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_1", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_1" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_8.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_2" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_9.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_2" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_10.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_2" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_11.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_2", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_2" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_12.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_3" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_13.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_3" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_14.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_3" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_15.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_3", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_3" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_16.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_4" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_17.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_4" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_18.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_4" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_19.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_4", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_4" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_20.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_5" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_21.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_5" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_22.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_5" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_23.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_5", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_5" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_24.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_6" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_25.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_6" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_26.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_6" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_27.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_6", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_6" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_28.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 4, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 8, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, - Stage6PointSlicePlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31.address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_7", offset: 12, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_7" }, - Stage6PointSlicePlan { symbol: "stage6.booleanity.output.point.Address", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 0, length: 4, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" }, - Stage6PointSlicePlan { symbol: "stage6.booleanity.output.point.Cycle", source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", offset: 16, length: 16, input: "stage6.input.stage5.instruction_read_raf.InstructionRa_0" }, -]; - -pub const STAGE6_POINT_CONCATS: &[Stage6PointConcatPlan] = &[ - Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0.address", layout: "left_zero_padded_address_chunk", arity: 4, inputs: &["stage6.bytecode_read_raf.point.BytecodeRa_0.address.zero_pad", "stage6.bytecode_read_raf.point.BytecodeRa_0.address.source"] }, - Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.bytecode_read_raf.point.BytecodeRa_0.address", "stage6.bytecode_read_raf.point.Cycle"] }, - Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.bytecode_read_raf.point.BytecodeRa_1.address", "stage6.bytecode_read_raf.point.Cycle"] }, - Stage6PointConcatPlan { symbol: "stage6.bytecode_read_raf.point.BytecodeRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.bytecode_read_raf.point.BytecodeRa_2.address", "stage6.bytecode_read_raf.point.Cycle"] }, - Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.ram_ra_virtual.point.RamRa_0.address", "stage6.ram_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.ram_ra_virtual.point.RamRa_1.address", "stage6.ram_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.ram_ra_virtual.point.RamRa_2.address", "stage6.ram_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.ram_ra_virtual.point.RamRa_3", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.ram_ra_virtual.point.RamRa_3.address", "stage6.ram_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_0", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_0.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_1", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_1.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_2", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_2.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_3", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_3.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_4", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_4.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_5", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_5.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_6", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_6.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_7", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_7.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_8", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_8.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_9", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_9.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_10", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_10.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_11", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_11.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_12", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_12.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_13", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_13.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_14", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_14.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_15", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_15.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_16", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_16.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_17", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_17.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_18", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_18.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_19", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_19.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_20", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_20.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_21", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_21.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_22", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_22.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_23", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_23.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_24", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_24.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_25", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_25.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_26", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_26.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_27", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_27.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_28", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_28.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_29", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_29.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_30", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_30.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.instruction_ra_virtual.point.InstructionRa_31", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage6.instruction_ra_virtual.point.InstructionRa_31.address", "stage6.instruction_ra_virtual.instance"] }, - Stage6PointConcatPlan { symbol: "stage6.booleanity.output.point", layout: "address_prefix_then_cycle", arity: 20, inputs: &["stage6.booleanity.output.point.Address", "stage6.booleanity.output.point.Cycle"] }, -]; pub const STAGE6_OPENING_CLAIMS: &[Stage6OpeningClaimPlan] = &[ Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_0", oracle: "BytecodeRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.bytecode_read_raf.point.BytecodeRa_0", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_0" }, Stage6OpeningClaimPlan { symbol: "stage6.bytecode_read_raf.opening.BytecodeRa_1", oracle: "BytecodeRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage6ClaimKind::Committed, point_source: "stage6.bytecode_read_raf.point.BytecodeRa_1", eval_source: "stage6.bytecode_read_raf.eval.BytecodeRa_1" }, @@ -705,9 +699,7 @@ pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { evals: STAGE6_SUMCHECK_EVALS, relation_output_values: STAGE6_RELATION_OUTPUT_VALUES, relation_outputs: STAGE6_RELATION_OUTPUTS, - point_zeros: STAGE6_POINT_ZEROS, - point_slices: STAGE6_POINT_SLICES, - point_concats: STAGE6_POINT_CONCATS, + point_exprs: STAGE6_POINT_EXPRS, opening_claims: STAGE6_OPENING_CLAIMS, opening_equalities: STAGE6_OPENING_EQUALITIES, opening_batches: STAGE6_OPENING_BATCHES, @@ -744,7 +736,6 @@ where let mut store = bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); - store.seed_point_zeros(program.point_zeros); let mut artifacts = Stage6ExecutionArtifacts::default(); for step in program.steps { match step.kind { @@ -879,8 +870,7 @@ where T: Transcript, { store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage6Error::InvalidInputLength { input, expected, @@ -948,8 +938,7 @@ fn observe_stage6_sumcheck_output( )?; store.evaluate_named_eval_families(STAGE6_INDEXED_EVAL_FAMILIES)?; store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage6Error::InvalidInputLength { input, expected, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 1ed1971b26..1533f67013 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -28,9 +28,8 @@ pub use bolt_verifier_runtime::{ KernelPlan as Stage7KernelPlan, OpeningBatchPlan as Stage7OpeningBatchPlan, OpeningClaimEqualityPlan as Stage7OpeningClaimEqualityPlan, OpeningClaimPlan as Stage7OpeningClaimPlan, OpeningInputPlan as Stage7OpeningInputPlan, - OpeningEqualityMode as Stage7OpeningEqualityMode, - PointConcatPlan as Stage7PointConcatPlan, PointSlicePlan as Stage7PointSlicePlan, - PointZeroPlan as Stage7PointZeroPlan, ProgramStepKind as Stage7ProgramStepKind, + OpeningEqualityMode as Stage7OpeningEqualityMode, PointExprKind as Stage7PointExprKind, + PointExprPlan as Stage7PointExprPlan, ProgramStepKind as Stage7ProgramStepKind, ProgramStepPlan as Stage7ProgramStepPlan, StageParams as Stage7Params, SumcheckBatchPlan as Stage7SumcheckBatchPlan, @@ -312,17 +311,11 @@ pub const STAGE7_SUMCHECK_EVALS: &[Stage7SumcheckEvalPlan] = &[ stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_1", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_1", 36, "RamRa_1"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_2", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_2", 37, "RamRa_2"), stage7_sumcheck_eval("stage7.hamming_weight_claim_reduction.eval.RamRa_3", "stage7.sumcheck", "stage7.hamming_weight_claim_reduction.eval.RamRa_3", 38, "RamRa_3"), ]; -pub const STAGE7_POINT_ZEROS: &[Stage7PointZeroPlan] = &[ - -]; - -pub const STAGE7_POINT_SLICES: &[Stage7PointSlicePlan] = &[ - Stage7PointSlicePlan { symbol: "stage7.hamming_weight_claim_reduction.point.cycle", source: "stage7.input.stage6.booleanity.InstructionRa_0", offset: 4, length: 16, input: "stage7.input.stage6.booleanity.InstructionRa_0" }, +pub const STAGE7_POINT_EXPRS: &[Stage7PointExprPlan] = &[ + Stage7PointExprPlan { symbol: "stage7.hamming_weight_claim_reduction.point.cycle", kind: Stage7PointExprKind::Slice { offset: 4, length: 16 }, operands: &["stage7.input.stage6.booleanity.InstructionRa_0"] }, + Stage7PointExprPlan { symbol: "stage7.hamming_weight_claim_reduction.point", kind: Stage7PointExprKind::Concat { layout: "address_chunk_then_cycle", arity: 20 }, operands: &["stage7.hamming_weight_claim_reduction.instance", "stage7.hamming_weight_claim_reduction.point.cycle"] }, ]; -pub const STAGE7_POINT_CONCATS: &[Stage7PointConcatPlan] = &[ - Stage7PointConcatPlan { symbol: "stage7.hamming_weight_claim_reduction.point", layout: "address_chunk_then_cycle", arity: 20, inputs: &["stage7.hamming_weight_claim_reduction.instance", "stage7.hamming_weight_claim_reduction.point.cycle"] }, -]; pub const STAGE7_OPENING_CLAIMS: &[Stage7OpeningClaimPlan] = &[ Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_0", oracle: "InstructionRa_0", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_0" }, Stage7OpeningClaimPlan { symbol: "stage7.hamming_weight_claim_reduction.opening.InstructionRa_1", oracle: "InstructionRa_1", domain: "jolt.main_witness_commit_domain", point_arity: 20, claim_kind: Stage7ClaimKind::Committed, point_source: "stage7.hamming_weight_claim_reduction.point", eval_source: "stage7.hamming_weight_claim_reduction.eval.InstructionRa_1" }, @@ -390,9 +383,7 @@ pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan { evals: STAGE7_SUMCHECK_EVALS, relation_output_values: STAGE7_RELATION_OUTPUT_VALUES, relation_outputs: STAGE7_RELATION_OUTPUTS, - point_zeros: STAGE7_POINT_ZEROS, - point_slices: STAGE7_POINT_SLICES, - point_concats: STAGE7_POINT_CONCATS, + point_exprs: STAGE7_POINT_EXPRS, opening_claims: STAGE7_OPENING_CLAIMS, opening_equalities: STAGE7_OPENING_EQUALITIES, opening_batches: STAGE7_OPENING_BATCHES, @@ -427,7 +418,6 @@ where let mut store = bolt_verifier_runtime::ValueStore::with_opening_inputs(opening_inputs, program.opening_inputs)?; store.seed_constants(program.field_constants); - store.seed_point_zeros(program.point_zeros); let mut artifacts = Stage7ExecutionArtifacts::default(); for step in program.steps { match step.kind { @@ -555,8 +545,7 @@ where T: Transcript, { store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage7Error::InvalidInputLength { input, expected, @@ -613,8 +602,7 @@ fn observe_stage7_sumcheck_output( |symbol| VerifyStage7Error::MissingValue { symbol }, )?; store.evaluate_available_points( - program.point_slices, - program.point_concats, + program.point_exprs, |input, expected, actual| VerifyStage7Error::InvalidInputLength { input, expected, From cde65538baf3c4ac15cb6c21b85ec1b8f72ef622 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 00:06:51 -0600 Subject: [PATCH 112/171] refactor(bolt): share point expression planning --- .../src/protocols/jolt/emit/rust/stage2.rs | 60 ++++++++++++------- .../bolt/src/protocols/jolt/verifier_plan.rs | 57 ++++++++++++------ 2 files changed, 77 insertions(+), 40 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 27f8279d5e..74eac6cbe1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -175,6 +175,42 @@ pub struct Stage2PointConcatPlan { pub inputs: Vec, } +impl verifier_plan::VerifierPointSliceSource for Stage2PointSlicePlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn offset(&self) -> usize { + self.offset + } + + fn length(&self) -> usize { + self.length + } + + fn input(&self) -> &str { + &self.input + } +} + +impl verifier_plan::VerifierPointConcatSource for Stage2PointConcatPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn layout(&self) -> &str { + &self.layout + } + + fn arity(&self) -> usize { + self.arity + } + + fn inputs(&self) -> &[String] { + &self.inputs + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage2OpeningClaimPlan { pub symbol: String, @@ -1606,28 +1642,8 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); fn emit_point_expr_constants(&self) -> Result { if self.role == Role::Verifier { - let mut point_exprs = self - .point_slices - .iter() - .map(|slice| verifier_plan::VerifierPointExprPlan { - symbol: slice.symbol.clone(), - kind: verifier_plan::VerifierPointExprKind::Slice { - offset: slice.offset, - length: slice.length, - }, - operands: vec![slice.input.clone()], - }) - .collect::>(); - point_exprs.extend(self.point_concats.iter().map(|concat| { - verifier_plan::VerifierPointExprPlan { - symbol: concat.symbol.clone(), - kind: verifier_plan::VerifierPointExprKind::Concat { - layout: concat.layout.clone(), - arity: concat.arity, - }, - operands: concat.inputs.clone(), - } - })); + let point_exprs = + verifier_plan::point_exprs_from_cpu(&self.point_slices, &self.point_concats); return Ok(verifier_plan::emit_point_expr_constants( "Stage2", "STAGE2", diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 7c4960826a..6112fbdbfa 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -867,6 +867,31 @@ pub(crate) fn point_concat_exprs_from_cpu( .collect() } +pub(crate) fn point_exprs_from_cpu(slices: &[S], concats: &[C]) -> Vec +where + S: VerifierPointSliceSource, + C: VerifierPointConcatSource, +{ + let mut exprs = point_slice_exprs_from_cpu(slices); + exprs.extend(point_concat_exprs_from_cpu(concats)); + exprs +} + +pub(crate) fn point_exprs_with_zeros_from_cpu( + zeros: &[Z], + slices: &[S], + concats: &[C], +) -> Vec +where + Z: VerifierPointZeroSource, + S: VerifierPointSliceSource, + C: VerifierPointConcatSource, +{ + let mut exprs = point_zero_exprs_from_cpu(zeros); + exprs.extend(point_exprs_from_cpu(slices, concats)); + exprs +} + macro_rules! impl_verifier_plan_source_traits { ( program = $program:ty, @@ -955,20 +980,9 @@ macro_rules! impl_verifier_plan_source_traits { &self.relation_outputs } fn point_exprs(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierPointExprPlan> { - let mut exprs = $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( - @point_zero_exprs self $(, $point_zero)? - ); - exprs.extend( - $crate::protocols::jolt::verifier_plan::point_slice_exprs_from_cpu( - &self.point_slices, - ), - ); - exprs.extend( - $crate::protocols::jolt::verifier_plan::point_concat_exprs_from_cpu( - &self.point_concats, - ), - ); - exprs + $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( + @point_exprs self $(, $point_zero)? + ) } fn opening_claims(&self) -> &[Self::OpeningClaim] { &self.opening_claims } fn opening_equalities(&self) -> &[Self::OpeningEquality] { &self.opening_equalities } @@ -1138,11 +1152,18 @@ macro_rules! impl_verifier_plan_source_traits { (@transcript_absorb_bytes $self:ident) => { Vec::new() }; - (@point_zero_exprs $self:ident, $point_zero:ty) => { - $crate::protocols::jolt::verifier_plan::point_zero_exprs_from_cpu(&$self.point_zeros) + (@point_exprs $self:ident, $point_zero:ty) => { + $crate::protocols::jolt::verifier_plan::point_exprs_with_zeros_from_cpu( + &$self.point_zeros, + &$self.point_slices, + &$self.point_concats, + ) }; - (@point_zero_exprs $self:ident) => { - Vec::new() + (@point_exprs $self:ident) => { + $crate::protocols::jolt::verifier_plan::point_exprs_from_cpu( + &$self.point_slices, + &$self.point_concats, + ) }; (@indexed_eval_families $self:ident, $indexed_eval_families:ident) => { &$self.$indexed_eval_families From 6e39d41359d14c3d9940bc2b7b7deb7aa39b5a7d Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 00:14:07 -0600 Subject: [PATCH 113/171] refactor(bolt): share indexed eval family helpers --- .../src/protocols/jolt/emit/rust/stage5.rs | 11 +--- .../src/protocols/jolt/emit/rust/stage6.rs | 11 +--- .../protocols/jolt/verifier_eval_families.rs | 64 ++++++++++++++++++- 3 files changed, 67 insertions(+), 19 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 678a7a2509..afacbe51fc 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -2120,12 +2120,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_indexed_eval_family_constants(&self) -> Result { - Ok(verifier_eval_families::emit_runtime_slice_constant( + Ok(verifier_eval_families::emit_named_runtime_slice_constant( &self.verifier_plan()?.indexed_eval_families, "pub ", "STAGE5_INDEXED_EVAL_FAMILY", "STAGE5_INDEXED_EVAL_FAMILIES", - "bolt_verifier_runtime::NamedEvalFamilyPlan", )) } @@ -2659,13 +2658,7 @@ fn parse_indexed_eval_family( ) -> Result { let symbol = string_attr(operation, "sym_name")?; let evals = symbol_array_attr(operation, "evals")?; - verify_count( - "indexed eval family", - &symbol, - int_attr(operation, "count")?, - evals.len(), - )?; - Ok(IndexedEvalFamilyPlan { symbol, evals }) + IndexedEvalFamilyPlan::from_parts(symbol, evals, int_attr(operation, "count")?) } fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result<(), EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index d9de58b938..590f1f6b07 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -2208,12 +2208,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); } fn emit_indexed_eval_family_constants(&self) -> Result { - Ok(verifier_eval_families::emit_runtime_slice_constant( + Ok(verifier_eval_families::emit_named_runtime_slice_constant( &self.verifier_plan()?.indexed_eval_families, "pub ", "STAGE6_INDEXED_EVAL_FAMILY", "STAGE6_INDEXED_EVAL_FAMILIES", - "bolt_verifier_runtime::NamedEvalFamilyPlan", )) } @@ -2919,13 +2918,7 @@ fn parse_indexed_eval_family( ) -> Result { let symbol = string_attr(operation, "sym_name")?; let evals = symbol_array_attr(operation, "evals")?; - verify_count( - "indexed eval family", - &symbol, - int_attr(operation, "count")?, - evals.len(), - )?; - Ok(IndexedEvalFamilyPlan { symbol, evals }) + IndexedEvalFamilyPlan::from_parts(symbol, evals, int_attr(operation, "count")?) } fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { diff --git a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs index 6e4d794900..d032d7470d 100644 --- a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs +++ b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs @@ -7,6 +7,20 @@ pub(crate) struct IndexedEvalFamilyPlan { } impl IndexedEvalFamilyPlan { + pub(crate) fn from_parts( + symbol: String, + evals: Vec, + count: usize, + ) -> Result { + if count != evals.len() { + return Err(EmitError::new(format!( + "indexed eval family @{symbol} count mismatch: expected {count}, got {}", + evals.len() + ))); + } + Ok(Self { symbol, evals }) + } + pub(crate) fn find<'a>( families: &'a [Self], symbol: &str, @@ -68,13 +82,30 @@ pub(crate) fn emit_runtime_slice_constant( source } +pub(crate) fn emit_named_runtime_slice_constant( + families: &[IndexedEvalFamilyPlan], + visibility: &str, + names_prefix: &str, + families_const: &str, +) -> String { + emit_runtime_slice_constant( + families, + visibility, + names_prefix, + families_const, + "bolt_verifier_runtime::NamedEvalFamilyPlan", + ) +} + fn rust_str(value: &str) -> String { format!("{value:?}") } #[cfg(test)] mod tests { - use super::{emit_runtime_slice_constant, IndexedEvalFamilyPlan}; + use super::{ + emit_named_runtime_slice_constant, emit_runtime_slice_constant, IndexedEvalFamilyPlan, + }; #[test] fn find_rejects_missing_families() { @@ -86,6 +117,22 @@ mod tests { assert!(error.contains("missing eval family `stage.eval.LookupTableFlag`")); } + #[test] + fn from_parts_rejects_count_mismatch() { + let error = IndexedEvalFamilyPlan::from_parts( + "stage.eval.BytecodeRa".to_owned(), + vec!["stage.eval.BytecodeRa_0".to_owned()], + 2, + ) + .err() + .map(|error| error.to_string()) + .unwrap_or_default(); + + assert!(error.contains( + "indexed eval family @stage.eval.BytecodeRa count mismatch: expected 2, got 1" + )); + } + #[test] fn find_rejects_duplicate_families() { let families = [ @@ -148,4 +195,19 @@ mod tests { assert!(source.contains("STAGE_EVAL_FAMILY_0_NAMES")); assert!(source.contains("stage.eval.BytecodeRa_1")); } + + #[test] + fn emit_named_runtime_slice_constant_uses_runtime_family_plan() { + let source = emit_named_runtime_slice_constant( + &[IndexedEvalFamilyPlan { + symbol: "stage.eval.BytecodeRa".to_owned(), + evals: vec!["stage.eval.BytecodeRa_0".to_owned()], + }], + "pub ", + "STAGE_EVAL_FAMILY", + "STAGE_EVAL_FAMILIES", + ); + + assert!(source.contains("bolt_verifier_runtime::NamedEvalFamilyPlan")); + } } From d0a76e2620e6a33b73bd972df4e43ae32b2b8dda Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 00:19:22 -0600 Subject: [PATCH 114/171] refactor(bolt): share indexed eval family parsing --- crates/bolt/src/protocols/jolt/cpu_attrs.rs | 72 +++++++++++++++++++ .../src/protocols/jolt/emit/rust/stage5.rs | 11 +-- .../src/protocols/jolt/emit/rust/stage6.rs | 11 +-- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../protocols/jolt/verifier_eval_families.rs | 11 +++ 5 files changed, 88 insertions(+), 18 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/cpu_attrs.rs diff --git a/crates/bolt/src/protocols/jolt/cpu_attrs.rs b/crates/bolt/src/protocols/jolt/cpu_attrs.rs new file mode 100644 index 0000000000..51a73a267b --- /dev/null +++ b/crates/bolt/src/protocols/jolt/cpu_attrs.rs @@ -0,0 +1,72 @@ +use melior::ir::operation::OperationLike; +use melior::ir::{Attribute, OperationRef}; + +use crate::emit::rust::EmitError; +use crate::ir::string_attribute_value; + +pub(crate) fn string_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result { + operation + .attribute(attr) + .ok() + .and_then(string_attribute_value) + .ok_or_else(|| attr_error(operation, attr, "string")) +} + +pub(crate) fn symbol_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, EmitError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "symbol array"))?; + parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) +} + +pub(crate) fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { + operation + .attribute(attr) + .map(parse_integer_attr) + .ok() + .flatten() + .ok_or_else(|| attr_error(operation, attr, "integer")) +} + +pub(crate) fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError { + EmitError::new(format!( + "{} attr `{attr}` is not a {expected}", + operation_name(operation) + )) +} + +pub(crate) fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { + operation + .name() + .as_string_ref() + .as_str() + .unwrap_or("") + .to_owned() +} + +fn parse_symbol_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned)) + .collect() +} + +fn parse_integer_attr(attribute: Attribute<'_>) -> Option { + attribute + .to_string() + .split_whitespace() + .next() + .and_then(|value| value.parse().ok()) +} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index afacbe51fc..4ad573af96 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -577,7 +577,8 @@ impl Stage5CpuProgram { }); } "cpu.sumcheck_eval_family" => { - indexed_eval_families.push(parse_indexed_eval_family(op)?); + indexed_eval_families + .push(verifier_eval_families::parse_indexed_eval_family(op)?); } "cpu.structured_polynomial_eval" => { let symbol = string_attr(op, "sym_name")?; @@ -2653,14 +2654,6 @@ fn expected_batched_output_claim( } } -fn parse_indexed_eval_family( - operation: OperationRef<'_, '_>, -) -> Result { - let symbol = string_attr(operation, "sym_name")?; - let evals = symbol_array_attr(operation, "evals")?; - IndexedEvalFamilyPlan::from_parts(symbol, evals, int_attr(operation, "count")?) -} - fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result<(), EmitError> { if actual == expected { Ok(()) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 590f1f6b07..444324fa62 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -575,7 +575,8 @@ impl Stage6CpuProgram { }); } "cpu.sumcheck_eval_family" => { - indexed_eval_families.push(parse_indexed_eval_family(op)?); + indexed_eval_families + .push(verifier_eval_families::parse_indexed_eval_family(op)?); } "cpu.structured_polynomial_eval" => { let symbol = string_attr(op, "sym_name")?; @@ -2913,14 +2914,6 @@ fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi)) } -fn parse_indexed_eval_family( - operation: OperationRef<'_, '_>, -) -> Result { - let symbol = string_attr(operation, "sym_name")?; - let evals = symbol_array_attr(operation, "evals")?; - IndexedEvalFamilyPlan::from_parts(symbol, evals, int_attr(operation, "count")?) -} - fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index 0262346423..39b37d195c 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -1,4 +1,5 @@ pub mod artifacts; +pub(crate) mod cpu_attrs; pub mod emit; pub mod oracles; pub mod params; diff --git a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs index d032d7470d..ab0463dbc9 100644 --- a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs +++ b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs @@ -1,4 +1,7 @@ +use melior::ir::OperationRef; + use crate::emit::rust::{push_format, EmitError}; +use crate::protocols::jolt::cpu_attrs::{int_attr, string_attr, symbol_array_attr}; #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct IndexedEvalFamilyPlan { @@ -97,6 +100,14 @@ pub(crate) fn emit_named_runtime_slice_constant( ) } +pub(crate) fn parse_indexed_eval_family( + operation: OperationRef<'_, '_>, +) -> Result { + let symbol = string_attr(operation, "sym_name")?; + let evals = symbol_array_attr(operation, "evals")?; + IndexedEvalFamilyPlan::from_parts(symbol, evals, int_attr(operation, "count")?) +} + fn rust_str(value: &str) -> String { format!("{value:?}") } From a5c1f9532b71442d5fddafec862a9278f890f462 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 00:27:26 -0600 Subject: [PATCH 115/171] refactor(bolt): share relation output attr parsing --- crates/bolt/src/protocols/jolt/cpu_attrs.rs | 67 +++++++++ .../jolt/verifier_relation_outputs.rs | 127 +----------------- 2 files changed, 72 insertions(+), 122 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/cpu_attrs.rs b/crates/bolt/src/protocols/jolt/cpu_attrs.rs index 51a73a267b..1de4efd4fd 100644 --- a/crates/bolt/src/protocols/jolt/cpu_attrs.rs +++ b/crates/bolt/src/protocols/jolt/cpu_attrs.rs @@ -27,6 +27,34 @@ pub(crate) fn symbol_array_attr( parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) } +pub(crate) fn optional_symbol_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, EmitError> { + let values = symbol_array_attr(operation, attr)?; + if values.len() <= 1 { + Ok(values) + } else { + Err(EmitError::new(format!( + "{} attr `{attr}` expected zero or one symbols, got {}", + operation_name(operation), + values.len() + ))) + } +} + +pub(crate) fn string_array_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result, EmitError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "string array"))?; + parse_string_array(&attribute).ok_or_else(|| attr_error(operation, attr, "string array")) +} + pub(crate) fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { operation .attribute(attr) @@ -36,6 +64,18 @@ pub(crate) fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, + attr: &str, +) -> Result, EmitError> { + let attribute = operation + .attribute(attr) + .map(|attribute| attribute.to_string()) + .ok() + .ok_or_else(|| attr_error(operation, attr, "integer array"))?; + parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) +} + pub(crate) fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError { EmitError::new(format!( "{} attr `{attr}` is not a {expected}", @@ -63,6 +103,22 @@ fn parse_symbol_array(attribute: &str) -> Option> { .collect() } +fn parse_string_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| { + item.trim() + .strip_prefix('"')? + .strip_suffix('"') + .map(ToOwned::to_owned) + }) + .collect() +} + fn parse_integer_attr(attribute: Attribute<'_>) -> Option { attribute .to_string() @@ -70,3 +126,14 @@ fn parse_integer_attr(attribute: Attribute<'_>) -> Option { .next() .and_then(|value| value.parse().ok()) } + +fn parse_int_array(attribute: &str) -> Option> { + let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); + if inner.is_empty() { + return Some(Vec::new()); + } + inner + .split(',') + .map(|item| item.trim().parse().ok()) + .collect() +} diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 56ca5ae933..0c7127d38f 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -1,13 +1,15 @@ use std::collections::{BTreeMap, BTreeSet}; use melior::ir::operation::{OperationLike, OperationResult}; -use melior::ir::{Attribute, OperationRef}; +use melior::ir::OperationRef; use crate::emit::rust::EmitError; -use crate::ir::string_attribute_value; +use crate::protocols::jolt::cpu_attrs::{ + int_array_attr, int_attr, operation_name, optional_symbol_array_attr, string_array_attr, + string_attr, symbol_array_attr, +}; use crate::protocols::jolt::rust_target_plan::power_strided_weighted_sum_formula; use crate::protocols::jolt::verifier_values::{VerifierPointSourceSet, VerifierScalarSourceSet}; -use crate::schema::operation_name; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum StructuredPolynomialKind { @@ -1455,118 +1457,6 @@ fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Res } } -fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(string_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "string")) -} - -fn symbol_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "symbol array"))?; - parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) -} - -fn optional_symbol_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let values = symbol_array_attr(operation, attr)?; - if values.len() <= 1 { - Ok(values) - } else { - Err(EmitError::new(format!( - "{} attr `{attr}` expected zero or one symbols, got {}", - operation_name(operation), - values.len() - ))) - } -} - -fn parse_symbol_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned)) - .collect() -} - -fn string_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "string array"))?; - parse_string_array(&attribute).ok_or_else(|| attr_error(operation, attr, "string array")) -} - -fn parse_string_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| { - item.trim() - .strip_prefix('"')? - .strip_suffix('"') - .map(ToOwned::to_owned) - }) - .collect() -} - -fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .map(parse_integer_attr) - .ok() - .flatten() - .ok_or_else(|| attr_error(operation, attr, "integer")) -} - -fn parse_integer_attr(attribute: Attribute<'_>) -> Option { - attribute - .to_string() - .split_whitespace() - .next() - .and_then(|value| value.parse().ok()) -} - -fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "integer array"))?; - parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) -} - -fn parse_int_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().parse().ok()) - .collect() -} - fn operand_symbols( operation: OperationRef<'_, '_>, start_index: usize, @@ -1593,13 +1483,6 @@ fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result, attr: &str, expected: &str) -> EmitError { - EmitError::new(format!( - "{} attr `{attr}` is not a {expected}", - operation_name(operation) - )) -} - #[cfg(test)] mod tests { use std::collections::BTreeSet; From 8049af73c659eaf3260e0e930704b33bbd335a01 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 00:54:39 -0600 Subject: [PATCH 116/171] refactor(bolt): slim relation output plans --- crates/bolt-verifier-runtime/src/lib.rs | 20 +-- .../jolt/emit/rust/relation_outputs.rs | 141 +----------------- .../src/protocols/jolt/emit/rust/stage3.rs | 8 - .../src/protocols/jolt/emit/rust/stage4.rs | 9 +- .../src/protocols/jolt/emit/rust/stage5.rs | 9 +- .../src/protocols/jolt/emit/rust/stage6.rs | 9 +- .../src/protocols/jolt/emit/rust/stage7.rs | 9 +- crates/bolt/tests/commitment_ir.rs | 13 +- crates/jolt-equivalence/src/plan_adapters.rs | 61 ++------ .../src/plan_adapters/generated_stage3.rs | 1 - .../src/plan_adapters/generated_stage4.rs | 3 +- .../src/plan_adapters/generated_stage5.rs | 3 +- .../src/plan_adapters/generated_stage6.rs | 3 +- .../src/plan_adapters/generated_stage7.rs | 3 +- crates/jolt-verifier/src/stages/stage3.rs | 20 +-- crates/jolt-verifier/src/stages/stage4.rs | 16 +- crates/jolt-verifier/src/stages/stage5.rs | 21 +-- crates/jolt-verifier/src/stages/stage6.rs | 30 +--- crates/jolt-verifier/src/stages/stage7.rs | 94 +----------- 19 files changed, 48 insertions(+), 425 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 0db55548f8..042c0567a3 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -383,7 +383,7 @@ pub enum StructuredPolynomialPointLength { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StructuredPolynomialPointPlan { +struct StructuredPolynomialPointPlan { pub source: &'static str, pub segment: StructuredPolynomialPointSegment, pub length: StructuredPolynomialPointLength, @@ -404,24 +404,9 @@ pub enum StructuredPolynomialKind { Lt, } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StructuredPolynomialEvalPlan { - pub symbol: &'static str, - pub polynomial: StructuredPolynomialKind, - pub x_point: StructuredPolynomialPointPlan, - pub y_point: StructuredPolynomialPointPlan, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StructuredPolynomialEvalRef { - pub symbol: &'static str, - pub index: usize, -} - #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: R, - pub structured_polynomial_evals: &'static [StructuredPolynomialEvalRef], pub local_scalars: &'static [&'static str], pub expected_output: &'static str, } @@ -501,7 +486,6 @@ pub struct StageProgramPlan { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], - pub relation_output_values: &'static [StructuredPolynomialEvalPlan], pub relation_outputs: &'static [RelationOutputPlan], pub point_exprs: &'static [PointExprPlan], pub opening_claims: &'static [OpeningClaimPlan], @@ -523,7 +507,6 @@ pub struct StageVerifierProgramPlan { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], - pub relation_output_values: &'static [StructuredPolynomialEvalPlan], pub relation_outputs: &'static [RelationOutputPlan], pub point_exprs: &'static [PointExprPlan], pub opening_claims: &'static [OpeningClaimPlan], @@ -2038,7 +2021,6 @@ mod tests { let value = evaluate_relation_output_for_instance( &[RelationOutputPlan { relation: TestRelation::Output, - structured_polynomial_evals: &[], local_scalars: &[], expected_output: "eq.xy", }], diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index 7bd06678ec..cba0ad4827 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -1,19 +1,13 @@ use crate::emit::rust::{push_format, EmitError}; use crate::ir::Role; -use crate::protocols::jolt::verifier_relation_outputs::{ - RelationOutputPlan, StructuredPolynomialEvalPlan, StructuredPolynomialEvalRefPlan, - StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, -}; +use crate::protocols::jolt::verifier_relation_outputs::RelationOutputPlan; pub fn emit_verifier_relation_output_constants( stage_type: &str, role: &Role, - relation_output_values: &[StructuredPolynomialEvalPlan], relation_outputs: &[RelationOutputPlan], ) -> Result { let mut source = String::new(); - emit_relation_output_value_constants(&mut source, stage_type, relation_output_values)?; let mut claims = Vec::new(); for (index, claim) in relation_outputs.iter().enumerate() { if let Some(family) = claim.eval_families.first() { @@ -28,18 +22,9 @@ pub fn emit_verifier_relation_output_constants( family.symbol ))); } - let values_name = format!( - "{}_RELATION_OUTPUT_{index}_STRUCTURED_POLYNOMIAL_EVALS", - stage_type.to_ascii_uppercase() - ); - let values = emit_structured_polynomial_eval_refs_slice_or_inline( - &mut source, - &values_name, - &claim.structured_polynomial_evals, - ); let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim); claims.push(format!( - " {stage_type}RelationOutputPlan {{ relation: {}, structured_polynomial_evals: {values}, local_scalars: {local_scalars}, expected_output: {} }},", + " {stage_type}RelationOutputPlan {{ relation: {}, local_scalars: {local_scalars}, expected_output: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, rust_str(&claim.expected_output) )); @@ -55,34 +40,6 @@ pub fn emit_verifier_relation_output_constants( Ok(source) } -fn emit_relation_output_value_constants( - source: &mut String, - stage_type: &str, - relation_output_values: &[StructuredPolynomialEvalPlan], -) -> Result<(), EmitError> { - let values_name = format!("{}_RELATION_OUTPUT_VALUES", stage_type.to_ascii_uppercase()); - let values = relation_output_values - .iter() - .map(|value| { - Ok(format!( - " {stage_type}StructuredPolynomialEvalPlan {{ symbol: {}, polynomial: {}, x_point: {}, y_point: {} }},", - rust_str(&value.symbol), - structured_polynomial_kind_expr(stage_type, value.polynomial), - structured_polynomial_point_expr(stage_type, &value.x_point), - structured_polynomial_point_expr(stage_type, &value.y_point), - )) - }) - .collect::, EmitError>>()? - .join("\n"); - push_format( - source, - format_args!( - "pub const {values_name}: &[{stage_type}StructuredPolynomialEvalPlan] = &[\n{values}\n];\n\n" - ), - ); - Ok(()) -} - fn emit_local_scalar_constants( source: &mut String, stage_type: &str, @@ -104,100 +61,6 @@ fn emit_local_scalar_constants( name } -fn emit_structured_polynomial_eval_refs_slice_or_inline( - source: &mut String, - name: &str, - values: &[StructuredPolynomialEvalRefPlan], -) -> String { - let rows = values - .iter() - .map(structured_polynomial_eval_ref_expr) - .collect::>(); - if values.len() <= 4 { - return format!("&[{}]", rows.join(", ")); - } - let rows = rows - .into_iter() - .map(|row| format!(" {row},")) - .collect::>() - .join("\n"); - push_format( - source, - format_args!( - "pub const {name}: &[bolt_verifier_runtime::StructuredPolynomialEvalRef] = &[\n{rows}\n];\n" - ), - ); - name.to_owned() -} - -fn structured_polynomial_eval_ref_expr(value: &StructuredPolynomialEvalRefPlan) -> String { - format!( - "bolt_verifier_runtime::StructuredPolynomialEvalRef {{ symbol: {}, index: {} }}", - rust_str(&value.symbol), - value.index - ) -} - -fn structured_polynomial_kind_expr( - stage_type: &str, - polynomial: StructuredPolynomialKind, -) -> String { - let variant = match polynomial { - StructuredPolynomialKind::Eq => "Eq", - StructuredPolynomialKind::EqPlusOne => "EqPlusOne", - StructuredPolynomialKind::Lt => "Lt", - }; - format!("{stage_type}StructuredPolynomialKind::{variant}") -} - -fn structured_polynomial_point_expr( - stage_type: &str, - point: &StructuredPolynomialPointPlan, -) -> String { - format!( - "{stage_type}StructuredPolynomialPointPlan {{ source: {}, segment: {}, length: {}, order: {} }}", - rust_str(&point.source), - structured_polynomial_point_segment_expr(stage_type, point.segment), - structured_polynomial_point_length_expr(stage_type, point.length), - structured_polynomial_point_order_expr(stage_type, point.order), - ) -} - -fn structured_polynomial_point_segment_expr( - stage_type: &str, - segment: StructuredPolynomialPointSegment, -) -> String { - let variant = match segment { - StructuredPolynomialPointSegment::Full => "Full", - StructuredPolynomialPointSegment::Prefix => "Prefix", - StructuredPolynomialPointSegment::Suffix => "Suffix", - }; - format!("{stage_type}StructuredPolynomialPointSegment::{variant}") -} - -fn structured_polynomial_point_length_expr( - stage_type: &str, - length: StructuredPolynomialPointLength, -) -> String { - let variant = match length { - StructuredPolynomialPointLength::Full => "Full", - StructuredPolynomialPointLength::XPoint => "XPoint", - StructuredPolynomialPointLength::YPoint => "YPoint", - }; - format!("{stage_type}StructuredPolynomialPointLength::{variant}") -} - -fn structured_polynomial_point_order_expr( - stage_type: &str, - order: StructuredPolynomialPointOrder, -) -> String { - let variant = match order { - StructuredPolynomialPointOrder::AsIs => "AsIs", - StructuredPolynomialPointOrder::Reverse => "Reverse", - }; - format!("{stage_type}StructuredPolynomialPointOrder::{variant}") -} - fn rust_str(value: &str) -> String { format!("{value:?}") } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 934bffdb16..4cc3ab5745 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1204,7 +1204,6 @@ pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage3RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; -pub type Stage3StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind; pub use bolt_verifier_runtime::{ @@ -1221,11 +1220,6 @@ pub use bolt_verifier_runtime::{ ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, - StructuredPolynomialPointLength as Stage3StructuredPolynomialPointLength, - StructuredPolynomialPointOrder as Stage3StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan as Stage3StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment as Stage3StructuredPolynomialPointSegment, - StructuredPolynomialKind as Stage3StructuredPolynomialKind, TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, }; @@ -1299,7 +1293,6 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); \x20 drivers: STAGE3_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE3_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE3_SUMCHECK_EVALS,\n\ - \x20 relation_output_values: STAGE3_RELATION_OUTPUT_VALUES,\n\ \x20 relation_outputs: STAGE3_RELATION_OUTPUTS,\n\ \x20 point_exprs: STAGE3_POINT_EXPRS,\n\ \x20 opening_claims: STAGE3_OPENING_CLAIMS,\n\ @@ -1782,7 +1775,6 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage3Error); super::relation_outputs::emit_verifier_relation_output_constants( "Stage3", &self.role, - &self.relation_output_values, &self.relation_outputs, ) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index d41cc9af09..cc80dbb18a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -1416,7 +1416,6 @@ pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage4RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; -pub type Stage4StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind; pub use bolt_verifier_runtime::{ @@ -1434,11 +1433,6 @@ pub use bolt_verifier_runtime::{ ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, SumcheckBatchPlan as Stage4SumcheckBatchPlan, SumcheckEvalPlan as Stage4SumcheckEvalPlan, - StructuredPolynomialPointLength as Stage4StructuredPolynomialPointLength, - StructuredPolynomialPointOrder as Stage4StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan as Stage4StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment as Stage4StructuredPolynomialPointSegment, - StructuredPolynomialKind as Stage4StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage4TranscriptSqueezeKind, TranscriptSqueezePlan as Stage4TranscriptSqueezePlan, @@ -1483,7 +1477,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); source.push_str(&self.emit_verifier_relation_output_constants()?); } let relation_outputs_field = if self.role == Role::Verifier { - " relation_output_values: STAGE4_RELATION_OUTPUT_VALUES,\n relation_outputs: STAGE4_RELATION_OUTPUTS,\n" + " relation_outputs: STAGE4_RELATION_OUTPUTS,\n" } else { "" }; @@ -2020,7 +2014,6 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); super::relation_outputs::emit_verifier_relation_output_constants( "Stage4", &self.role, - &self.relation_output_values, &self.relation_outputs, ) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 4ad573af96..0ef4d6566d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1543,7 +1543,6 @@ pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage5RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; -pub type Stage5StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage5RelationKind; pub use bolt_verifier_runtime::{ @@ -1561,11 +1560,6 @@ pub use bolt_verifier_runtime::{ ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params, SumcheckBatchPlan as Stage5SumcheckBatchPlan, SumcheckEvalPlan as Stage5SumcheckEvalPlan, - StructuredPolynomialPointLength as Stage5StructuredPolynomialPointLength, - StructuredPolynomialPointOrder as Stage5StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment as Stage5StructuredPolynomialPointSegment, - StructuredPolynomialKind as Stage5StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage5TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage5TranscriptSqueezeKind, TranscriptSqueezePlan as Stage5TranscriptSqueezePlan, @@ -1611,7 +1605,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); source.push_str(&self.emit_verifier_relation_output_constants()?); } let relation_outputs_field = if self.role == Role::Verifier { - " relation_output_values: STAGE5_RELATION_OUTPUT_VALUES,\n relation_outputs: STAGE5_RELATION_OUTPUTS,\n" + " relation_outputs: STAGE5_RELATION_OUTPUTS,\n" } else { "" }; @@ -2140,7 +2134,6 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); super::relation_outputs::emit_verifier_relation_output_constants( "Stage5", &self.role, - &self.relation_output_values, &self.relation_outputs, ) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 444324fa62..19eb922912 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1559,7 +1559,6 @@ pub type Stage6SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage6SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage6RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; -pub type Stage6StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage6RelationKind; pub use bolt_verifier_runtime::{ @@ -1577,11 +1576,6 @@ pub use bolt_verifier_runtime::{ StageParams as Stage6Params, SumcheckBatchPlan as Stage6SumcheckBatchPlan, SumcheckEvalPlan as Stage6SumcheckEvalPlan, - StructuredPolynomialPointLength as Stage6StructuredPolynomialPointLength, - StructuredPolynomialPointOrder as Stage6StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment as Stage6StructuredPolynomialPointSegment, - StructuredPolynomialKind as Stage6StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage6TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage6TranscriptSqueezeKind, TranscriptSqueezePlan as Stage6TranscriptSqueezePlan, @@ -1689,7 +1683,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&self.emit_verifier_relation_output_constants()?); } let relation_outputs_field = if self.role == Role::Verifier { - " relation_output_values: STAGE6_RELATION_OUTPUT_VALUES,\n relation_outputs: STAGE6_RELATION_OUTPUTS,\n" + " relation_outputs: STAGE6_RELATION_OUTPUTS,\n" } else { "" }; @@ -2221,7 +2215,6 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); super::relation_outputs::emit_verifier_relation_output_constants( "Stage6", &self.role, - &self.relation_output_values, &self.relation_outputs, ) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 2cb450a864..1dbcd8cb31 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1672,7 +1672,6 @@ pub type Stage7SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage7SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage7RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; -pub type Stage7StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage7RelationKind; pub use bolt_verifier_runtime::{ @@ -1690,11 +1689,6 @@ pub use bolt_verifier_runtime::{ StageParams as Stage7Params, SumcheckBatchPlan as Stage7SumcheckBatchPlan, SumcheckEvalPlan as Stage7SumcheckEvalPlan, - StructuredPolynomialKind as Stage7StructuredPolynomialKind, - StructuredPolynomialPointLength as Stage7StructuredPolynomialPointLength, - StructuredPolynomialPointOrder as Stage7StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment as Stage7StructuredPolynomialPointSegment, TranscriptAbsorbBytesPlan as Stage7TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage7TranscriptSqueezeKind, TranscriptSqueezePlan as Stage7TranscriptSqueezePlan, @@ -1739,7 +1733,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); } source.push_str(&self.emit_tail_constants()?); let relation_outputs_field = if self.role == Role::Verifier { - " relation_output_values: STAGE7_RELATION_OUTPUT_VALUES,\n relation_outputs: STAGE7_RELATION_OUTPUTS,\n" + " relation_outputs: STAGE7_RELATION_OUTPUTS,\n" } else { "" }; @@ -2262,7 +2256,6 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); super::relation_outputs::emit_verifier_relation_output_constants( "Stage7", &self.role, - &self.relation_output_values, &self.relation_outputs, ) } diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index cd10c1f3fa..68a5cf4eee 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1770,16 +1770,21 @@ fn stage6_rust_targets_extract_and_compile() { assert!(bytecode_claims[0].structured_polynomial_evals.is_empty()); assert!(bytecode_claims[0].eval_families.is_empty()); assert!(bytecode_claims[0].product_families.is_empty()); - let bytecode_output_exprs = verifier_program - .field_exprs + let bytecode_output_scalar_exprs = verifier_program + .scalar_exprs .iter() .filter(|expr| expr.symbol.starts_with("stage6.bytecode_read_raf.output.")) .collect::>(); - assert!(bytecode_output_exprs.iter().any(|expr| { + assert!(bytecode_output_scalar_exprs.iter().any(|expr| { expr.symbol == "stage6.bytecode_read_raf.output.product.BytecodeRa" && expr.formula == "field_vector.product" && expr.operands == vec!["stage6.bytecode_read_raf.eval.BytecodeRa".to_owned()] })); + let bytecode_output_exprs = verifier_program + .field_exprs + .iter() + .filter(|expr| expr.symbol.starts_with("stage6.bytecode_read_raf.output.")) + .collect::>(); assert!(bytecode_output_exprs.iter().any(|expr| { expr.symbol == "stage6.bytecode_read_raf.output.claim_expr" && expr.formula == "field.product" @@ -1884,7 +1889,7 @@ fn stage6_rust_targets_extract_and_compile() { .contains("stage6.bytecode_read_raf.output.claim_expr")); assert!(verifier_source .source - .contains("Stage6FieldExprKind::FieldVectorProduct")); + .contains("Stage6ScalarExprKind::FieldVectorProduct")); assert!(!verifier_source .source .contains("expected_stage67_bytecode_read_raf")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 94f7e46f84..11ef57f2e3 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -585,7 +585,7 @@ macro_rules! define_stage_adapter_impl { $(, generated_points_with_zeros = $generated_point_with_zeros:ident, $generated_point_zero:ident)? $(, kernel_points = $kernel_point_slice:ident, $kernel_point_concat:ident)? $(, kernel_points_with_zeros = $kernel_point_slice_with_zeros:ident, $kernel_point_concat_with_zeros:ident, $kernel_point_zero:ident)? - $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? ) => { @@ -750,43 +750,12 @@ macro_rules! define_stage_adapter_impl { .collect(), ), $( - relation_output_values: super::leak_slice( - program - .relation_output_values - .iter() - .map(|value| $module::$relation_output_value { - symbol: super::leak_str(&value.symbol), - polynomial: super::generated_structured_polynomial_kind(value.polynomial.as_str()), - x_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { - source: super::leak_str(&value.x_point.source), - segment: super::generated_structured_polynomial_point_segment(value.x_point.segment.as_str()), - length: super::generated_structured_polynomial_point_length(value.x_point.length.as_str()), - order: super::generated_structured_polynomial_point_order(value.x_point.order.as_str()), - }, - y_point: bolt_verifier_runtime::StructuredPolynomialPointPlan { - source: super::leak_str(&value.y_point.source), - segment: super::generated_structured_polynomial_point_segment(value.y_point.segment.as_str()), - length: super::generated_structured_polynomial_point_length(value.y_point.length.as_str()), - order: super::generated_structured_polynomial_point_order(value.y_point.order.as_str()), - }, - }) - .collect(), - ), relation_outputs: super::leak_slice( program .relation_outputs .iter() .map(|plan| $module::$relation_output { relation: super::generated_relation_kind(&plan.relation), - structured_polynomial_evals: super::leak_slice( - plan.structured_polynomial_evals - .iter() - .map(|value| bolt_verifier_runtime::StructuredPolynomialEvalRef { - symbol: super::leak_str(&value.symbol), - index: value.index, - }) - .collect(), - ), local_scalars: super::leak_str_slice(&plan.local_scalars), expected_output: super::leak_str(&plan.expected_output), }) @@ -794,10 +763,6 @@ macro_rules! define_stage_adapter_impl { ), )? $( - relation_output_values: { - let _ = stringify!($empty_relation_outputs); - &[] - }, relation_outputs: { let _ = stringify!($empty_relation_outputs); &[] @@ -960,7 +925,7 @@ macro_rules! define_stage_adapter { point_zero = $point_zero:ident $(, scalar_expr = $scalar_expr:ident)? $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? - $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? ) => { define_stage_adapter_impl!( @@ -989,7 +954,7 @@ macro_rules! define_stage_adapter { $(, empty_scalar_exprs = $empty_scalar_exprs)? , generated_points_with_zeros = $point_expr, $point_zero - $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, relation_outputs = $relation_output)? $(, empty_relation_outputs = $empty_relation_outputs)? , opening_equalities = $opening_equality @@ -1021,7 +986,7 @@ macro_rules! define_stage_adapter { $opening_batch:ident $(, scalar_expr = $scalar_expr:ident)? $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? - $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? ) => { define_stage_adapter_impl!( @@ -1050,7 +1015,7 @@ macro_rules! define_stage_adapter { $(, empty_scalar_exprs = $empty_scalar_exprs)? , generated_points = $point_expr - $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, relation_outputs = $relation_output)? $(, empty_relation_outputs = $empty_relation_outputs)? , opening_equalities = $opening_equality @@ -1083,7 +1048,7 @@ macro_rules! define_stage_adapter { point_zero = $point_zero:ident $(, scalar_expr = $scalar_expr:ident)? $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? - $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? ) => { define_stage_adapter_impl!( @@ -1112,7 +1077,7 @@ macro_rules! define_stage_adapter { $(, empty_scalar_exprs = $empty_scalar_exprs)? , kernel_points_with_zeros = $point_slice, $point_concat, $point_zero - $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, relation_outputs = $relation_output)? $(, empty_relation_outputs = $empty_relation_outputs)? , opening_equalities = $opening_equality @@ -1144,7 +1109,7 @@ macro_rules! define_stage_adapter { $opening_batch:ident $(, scalar_expr = $scalar_expr:ident)? $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? - $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? ) => { define_stage_adapter_impl!( @@ -1173,7 +1138,7 @@ macro_rules! define_stage_adapter { $(, empty_scalar_exprs = $empty_scalar_exprs)? , kernel_points = $point_slice, $point_concat - $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, relation_outputs = $relation_output)? $(, empty_relation_outputs = $empty_relation_outputs)? , opening_equalities = $opening_equality @@ -1206,7 +1171,7 @@ macro_rules! define_stage_adapter_no_absorb { $(, kernels = $kernel:ident)? $(, scalar_expr = $scalar_expr:ident)? $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? - $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? ) => { @@ -1234,7 +1199,7 @@ macro_rules! define_stage_adapter_no_absorb { $(, empty_scalar_exprs = $empty_scalar_exprs)? , generated_points = $point_expr - $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, relation_outputs = $relation_output)? $(, empty_relation_outputs = $empty_relation_outputs)? $(, opening_equalities = $opening_equality)? ); @@ -1263,7 +1228,7 @@ macro_rules! define_stage_adapter_no_absorb { $(, kernels = $kernel:ident)? $(, scalar_expr = $scalar_expr:ident)? $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? - $(, relation_outputs = $relation_output:ident, relation_output_values = $relation_output_value:ident)? + $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? ) => { @@ -1291,7 +1256,7 @@ macro_rules! define_stage_adapter_no_absorb { $(, empty_scalar_exprs = $empty_scalar_exprs)? , kernel_points = $point_slice, $point_concat - $(, relation_outputs = $relation_output, relation_output_values = $relation_output_value)? + $(, relation_outputs = $relation_output)? $(, empty_relation_outputs = $empty_relation_outputs)? $(, opening_equalities = $opening_equality)? ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs index 2fd160638f..8b424386f3 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage3.rs @@ -24,6 +24,5 @@ define_stage_adapter_no_absorb!( Stage3OpeningBatchPlan, scalar_expr = Stage3ScalarExprPlan, relation_outputs = Stage3RelationOutputPlan, - relation_output_values = Stage3StructuredPolynomialEvalPlan, opening_equalities = Stage3OpeningClaimEqualityPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs index b79c998c68..6159c03f91 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs @@ -26,6 +26,5 @@ define_stage_adapter!( Stage4OpeningClaimEqualityPlan, Stage4OpeningBatchPlan, scalar_expr = Stage4ScalarExprPlan, - relation_outputs = Stage4RelationOutputPlan, - relation_output_values = Stage4StructuredPolynomialEvalPlan + relation_outputs = Stage4RelationOutputPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs index 6db160d3e7..4a77eb7f75 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs @@ -26,6 +26,5 @@ define_stage_adapter!( Stage5OpeningClaimEqualityPlan, Stage5OpeningBatchPlan, scalar_expr = Stage5ScalarExprPlan, - relation_outputs = Stage5RelationOutputPlan, - relation_output_values = Stage5StructuredPolynomialEvalPlan + relation_outputs = Stage5RelationOutputPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs index a755f2ade6..9525d425f7 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs @@ -27,6 +27,5 @@ define_stage_adapter!( Stage6OpeningBatchPlan, point_zero = Stage6PointExprPlan, scalar_expr = Stage6ScalarExprPlan, - relation_outputs = Stage6RelationOutputPlan, - relation_output_values = Stage6StructuredPolynomialEvalPlan + relation_outputs = Stage6RelationOutputPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs index d16fdd2463..77d622cae9 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs @@ -27,6 +27,5 @@ define_stage_adapter!( Stage7OpeningBatchPlan, point_zero = Stage7PointExprPlan, scalar_expr = Stage7ScalarExprPlan, - relation_outputs = Stage7RelationOutputPlan, - relation_output_values = Stage7StructuredPolynomialEvalPlan + relation_outputs = Stage7RelationOutputPlan ); diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 325f87b092..9c5165e788 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -18,7 +18,6 @@ pub type Stage3SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage3SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage3RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; -pub type Stage3StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage3RelationKind; pub use bolt_verifier_runtime::{ @@ -35,11 +34,6 @@ pub use bolt_verifier_runtime::{ ProgramStepKind as Stage3ProgramStepKind, ProgramStepPlan as Stage3ProgramStepPlan, StageParams as Stage3Params, SumcheckBatchPlan as Stage3SumcheckBatchPlan, SumcheckEvalPlan as Stage3SumcheckEvalPlan, - StructuredPolynomialPointLength as Stage3StructuredPolynomialPointLength, - StructuredPolynomialPointOrder as Stage3StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan as Stage3StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment as Stage3StructuredPolynomialPointSegment, - StructuredPolynomialKind as Stage3StructuredPolynomialKind, TranscriptSqueezeKind as Stage3TranscriptSqueezeKind, TranscriptSqueezePlan as Stage3TranscriptSqueezePlan, }; @@ -215,17 +209,10 @@ pub const STAGE3_OPENING_EQUALITIES: &[Stage3OpeningClaimEqualityPlan] = &[ pub const STAGE3_OPENING_BATCHES: &[Stage3OpeningBatchPlan] = &[ Stage3OpeningBatchPlan { symbol: "stage3.openings", stage: "stage3", proof_slot: "stage3.openings", policy: "jolt_stage3_output_order", count: 16, ordered_claims: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"], claim_operands: &["stage3.spartan_shift.opening.UnexpandedPC", "stage3.spartan_shift.opening.PC", "stage3.spartan_shift.opening.OpFlagVirtualInstruction", "stage3.spartan_shift.opening.OpFlagIsFirstInSequence", "stage3.spartan_shift.opening.InstructionFlagIsNoop", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsRs1Value", "stage3.instruction_input.opening.Rs1Value", "stage3.instruction_input.opening.InstructionFlagLeftOperandIsPC", "stage3.instruction_input.opening.UnexpandedPC", "stage3.instruction_input.opening.InstructionFlagRightOperandIsRs2Value", "stage3.instruction_input.opening.Rs2Value", "stage3.instruction_input.opening.InstructionFlagRightOperandIsImm", "stage3.instruction_input.opening.Imm", "stage3.registers_claim_reduction.opening.RdWriteValue", "stage3.registers_claim_reduction.opening.Rs1Value", "stage3.registers_claim_reduction.opening.Rs2Value"] }, ]; -pub const STAGE3_RELATION_OUTPUT_VALUES: &[Stage3StructuredPolynomialEvalPlan] = &[ - Stage3StructuredPolynomialEvalPlan { symbol: "stage3.spartan_shift.output.eq.NextPC", polynomial: Stage3StructuredPolynomialKind::EqPlusOne, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage1.NextPC", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, - Stage3StructuredPolynomialEvalPlan { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", polynomial: Stage3StructuredPolynomialKind::EqPlusOne, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.spartan_shift.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage2.product_virtual.NextIsNoop", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, - Stage3StructuredPolynomialEvalPlan { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", polynomial: Stage3StructuredPolynomialKind::Eq, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.instruction_input.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage2.product_virtual.LeftInstructionInput", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, - Stage3StructuredPolynomialEvalPlan { symbol: "stage3.registers.output.eq.RdWriteValue", polynomial: Stage3StructuredPolynomialKind::Eq, x_point: Stage3StructuredPolynomialPointPlan { source: "stage3.registers_claim_reduction.instance", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::Reverse }, y_point: Stage3StructuredPolynomialPointPlan { source: "stage3.input.stage1.RdWriteValue", segment: Stage3StructuredPolynomialPointSegment::Full, length: Stage3StructuredPolynomialPointLength::Full, order: Stage3StructuredPolynomialPointOrder::AsIs } }, -]; - pub const STAGE3_RELATION_OUTPUTS: &[Stage3RelationOutputPlan] = &[ - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextPC", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.spartan_shift.output.eq.NextIsNoop", index: 1 }], local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.instruction_input.output.eq.LeftInstructionInput", index: 2 }], local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, - Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage3.registers.output.eq.RdWriteValue", index: 3 }], local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3SpartanShift, local_scalars: &[], expected_output: "stage3.spartan_shift.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3InstructionInput, local_scalars: &[], expected_output: "stage3.instruction_input.output.claim_expr" }, + Stage3RelationOutputPlan { relation: Stage3RelationKind::Stage3RegistersClaimReduction, local_scalars: &[], expected_output: "stage3.registers.output.claim_expr" }, ]; pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan { @@ -241,7 +228,6 @@ pub const STAGE3_PROGRAM: Stage3VerifierProgramPlan = Stage3VerifierProgramPlan drivers: STAGE3_SUMCHECK_DRIVERS, instance_results: STAGE3_SUMCHECK_INSTANCE_RESULTS, evals: STAGE3_SUMCHECK_EVALS, - relation_output_values: STAGE3_RELATION_OUTPUT_VALUES, relation_outputs: STAGE3_RELATION_OUTPUTS, point_exprs: STAGE3_POINT_EXPRS, opening_claims: STAGE3_OPENING_CLAIMS, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 1ef6f51d97..c795fb3f35 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -16,7 +16,6 @@ pub type Stage4SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage4SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage4RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; -pub type Stage4StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage4RelationKind; pub use bolt_verifier_runtime::{ @@ -34,11 +33,6 @@ pub use bolt_verifier_runtime::{ ProgramStepPlan as Stage4ProgramStepPlan, StageParams as Stage4Params, SumcheckBatchPlan as Stage4SumcheckBatchPlan, SumcheckEvalPlan as Stage4SumcheckEvalPlan, - StructuredPolynomialPointLength as Stage4StructuredPolynomialPointLength, - StructuredPolynomialPointOrder as Stage4StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan as Stage4StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment as Stage4StructuredPolynomialPointSegment, - StructuredPolynomialKind as Stage4StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage4TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage4TranscriptSqueezeKind, TranscriptSqueezePlan as Stage4TranscriptSqueezePlan, @@ -178,14 +172,9 @@ pub const STAGE4_OPENING_EQUALITIES: &[Stage4OpeningClaimEqualityPlan] = &[ pub const STAGE4_OPENING_BATCHES: &[Stage4OpeningBatchPlan] = &[ Stage4OpeningBatchPlan { symbol: "stage4.openings", stage: "stage4", proof_slot: "stage4.openings", policy: "jolt_stage4_output_order", count: 7, ordered_claims: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"], claim_operands: &["stage4.registers_read_write.opening.RegistersVal", "stage4.registers_read_write.opening.Rs1Ra", "stage4.registers_read_write.opening.Rs2Ra", "stage4.registers_read_write.opening.RdWa", "stage4.registers_read_write.opening.RdInc", "stage4.ram_val_check.opening.RamRa", "stage4.ram_val_check.opening.RamInc"] }, ]; -pub const STAGE4_RELATION_OUTPUT_VALUES: &[Stage4StructuredPolynomialEvalPlan] = &[ - Stage4StructuredPolynomialEvalPlan { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", polynomial: Stage4StructuredPolynomialKind::Eq, x_point: Stage4StructuredPolynomialPointPlan { source: "stage4.registers_read_write.instance", segment: Stage4StructuredPolynomialPointSegment::Prefix, length: Stage4StructuredPolynomialPointLength::YPoint, order: Stage4StructuredPolynomialPointOrder::Reverse }, y_point: Stage4StructuredPolynomialPointPlan { source: "stage4.input.stage3.registers.RdWriteValue", segment: Stage4StructuredPolynomialPointSegment::Full, length: Stage4StructuredPolynomialPointLength::Full, order: Stage4StructuredPolynomialPointOrder::AsIs } }, - Stage4StructuredPolynomialEvalPlan { symbol: "stage4.ram_val_check.output.lt.RamValCycle", polynomial: Stage4StructuredPolynomialKind::Lt, x_point: Stage4StructuredPolynomialPointPlan { source: "stage4.ram_val_check.instance", segment: Stage4StructuredPolynomialPointSegment::Full, length: Stage4StructuredPolynomialPointLength::Full, order: Stage4StructuredPolynomialPointOrder::Reverse }, y_point: Stage4StructuredPolynomialPointPlan { source: "stage4.input.stage2.RamVal", segment: Stage4StructuredPolynomialPointSegment::Suffix, length: Stage4StructuredPolynomialPointLength::XPoint, order: Stage4StructuredPolynomialPointOrder::AsIs } }, -]; - pub const STAGE4_RELATION_OUTPUTS: &[Stage4RelationOutputPlan] = &[ - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.registers_read_write.output.eq.RdWriteValue", index: 0 }], local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, - Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage4.ram_val_check.output.lt.RamValCycle", index: 1 }], local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RegistersReadWrite, local_scalars: &[], expected_output: "stage4.registers_read_write.output.claim_expr" }, + Stage4RelationOutputPlan { relation: Stage4RelationKind::Stage4RamValCheck, local_scalars: &[], expected_output: "stage4.ram_val_check.output.claim_expr" }, ]; pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { @@ -204,7 +193,6 @@ pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { drivers: STAGE4_SUMCHECK_DRIVERS, instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS, evals: STAGE4_SUMCHECK_EVALS, - relation_output_values: STAGE4_RELATION_OUTPUT_VALUES, relation_outputs: STAGE4_RELATION_OUTPUTS, point_exprs: STAGE4_POINT_EXPRS, opening_claims: STAGE4_OPENING_CLAIMS, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index d446b13c01..438db0b00e 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -17,7 +17,6 @@ pub type Stage5SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage5SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage5RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; -pub type Stage5StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage5RelationKind; pub use bolt_verifier_runtime::{ @@ -35,11 +34,6 @@ pub use bolt_verifier_runtime::{ ProgramStepPlan as Stage5ProgramStepPlan, StageParams as Stage5Params, SumcheckBatchPlan as Stage5SumcheckBatchPlan, SumcheckEvalPlan as Stage5SumcheckEvalPlan, - StructuredPolynomialPointLength as Stage5StructuredPolynomialPointLength, - StructuredPolynomialPointOrder as Stage5StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment as Stage5StructuredPolynomialPointSegment, - StructuredPolynomialKind as Stage5StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage5TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage5TranscriptSqueezeKind, TranscriptSqueezePlan as Stage5TranscriptSqueezePlan, @@ -409,19 +403,11 @@ pub const STAGE5_INDEXED_EVAL_FAMILIES: &[bolt_verifier_runtime::NamedEvalFamily bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.InstructionRa", evals: STAGE5_INDEXED_EVAL_FAMILY_1_NAMES }, ]; -pub const STAGE5_RELATION_OUTPUT_VALUES: &[Stage5StructuredPolynomialEvalPlan] = &[ - Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.ram_raf.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, - Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.ram_read_write.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, - Stage5StructuredPolynomialEvalPlan { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.ram_ra_claim_reduction.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage4.ram_val_check.RamRa", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, - Stage5StructuredPolynomialEvalPlan { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", polynomial: Stage5StructuredPolynomialKind::Lt, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.registers_val_evaluation.instance", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage4.registers.RegistersVal", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::XPoint, order: Stage5StructuredPolynomialPointOrder::AsIs } }, - Stage5StructuredPolynomialEvalPlan { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", polynomial: Stage5StructuredPolynomialKind::Eq, x_point: Stage5StructuredPolynomialPointPlan { source: "stage5.instruction_read_raf.instance", segment: Stage5StructuredPolynomialPointSegment::Suffix, length: Stage5StructuredPolynomialPointLength::YPoint, order: Stage5StructuredPolynomialPointOrder::Reverse }, y_point: Stage5StructuredPolynomialPointPlan { source: "stage5.input.stage2.instruction.LookupOutput", segment: Stage5StructuredPolynomialPointSegment::Full, length: Stage5StructuredPolynomialPointLength::Full, order: Stage5StructuredPolynomialPointOrder::AsIs } }, -]; - pub const STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; pub const STAGE5_RELATION_OUTPUTS: &[Stage5RelationOutputPlan] = &[ - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.Raf", index: 0 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ReadWrite", index: 1 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.ram_ra_claim_reduction.output.eq.ValCheck", index: 2 }], local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.registers_val_evaluation.output.lt.RegistersValCycle", index: 3 }], local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, - Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage5.instruction_read_raf.output.eq.LookupOutputCycle", index: 4 }], local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, + Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, ]; pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { @@ -440,7 +426,6 @@ pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { drivers: STAGE5_SUMCHECK_DRIVERS, instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS, evals: STAGE5_SUMCHECK_EVALS, - relation_output_values: STAGE5_RELATION_OUTPUT_VALUES, relation_outputs: STAGE5_RELATION_OUTPUTS, point_exprs: STAGE5_POINT_EXPRS, opening_claims: STAGE5_OPENING_CLAIMS, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 4a95a8810f..2e16a82747 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -17,7 +17,6 @@ pub type Stage6SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage6SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage6RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; -pub type Stage6StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage6RelationKind; pub use bolt_verifier_runtime::{ @@ -35,11 +34,6 @@ pub use bolt_verifier_runtime::{ StageParams as Stage6Params, SumcheckBatchPlan as Stage6SumcheckBatchPlan, SumcheckEvalPlan as Stage6SumcheckEvalPlan, - StructuredPolynomialPointLength as Stage6StructuredPolynomialPointLength, - StructuredPolynomialPointOrder as Stage6StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment as Stage6StructuredPolynomialPointSegment, - StructuredPolynomialKind as Stage6StructuredPolynomialKind, TranscriptAbsorbBytesPlan as Stage6TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage6TranscriptSqueezeKind, TranscriptSqueezePlan as Stage6TranscriptSqueezePlan, @@ -660,25 +654,14 @@ const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafP }, entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; -pub const STAGE6_RELATION_OUTPUT_VALUES: &[Stage6StructuredPolynomialEvalPlan] = &[ - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.booleanity.output.eq.InstructionRa0", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.booleanity.output.point", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs } }, - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.hamming_booleanity.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::AsIs }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage1.LookupOutput", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse } }, - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.ram_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.ram_ra_claim_reduction.RamRa", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.instruction_ra_virtual.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.instruction_read_raf.InstructionRa_0", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage2.ram_read_write.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.ram_val_check.RamInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage4.registers_read_write.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, - Stage6StructuredPolynomialEvalPlan { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", polynomial: Stage6StructuredPolynomialKind::Eq, x_point: Stage6StructuredPolynomialPointPlan { source: "stage6.inc_claim_reduction.instance", segment: Stage6StructuredPolynomialPointSegment::Full, length: Stage6StructuredPolynomialPointLength::Full, order: Stage6StructuredPolynomialPointOrder::Reverse }, y_point: Stage6StructuredPolynomialPointPlan { source: "stage6.input.stage5.registers_val_evaluation.RdInc", segment: Stage6StructuredPolynomialPointSegment::Suffix, length: Stage6StructuredPolynomialPointLength::XPoint, order: Stage6StructuredPolynomialPointOrder::AsIs } }, -]; - pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.booleanity.output.eq.InstructionRa0", index: 0 }], local_scalars: &[], expected_output: "stage6.booleanity.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.hamming_booleanity.output.eq.LookupOutput", index: 1 }], local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.ram_ra_virtual.output.eq.Cycle", index: 2 }], local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.instruction_ra_virtual.output.eq.Cycle", index: 3 }], local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, structured_polynomial_evals: &[bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage2", index: 4 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RamIncStage4", index: 5 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage4", index: 6 }, bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage6.inc_claim_reduction.output.eq.RdIncStage5", index: 7 }], local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, - Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, structured_polynomial_evals: &[], local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, local_scalars: &[], expected_output: "stage6.booleanity.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6RamRaVirtual, local_scalars: &[], expected_output: "stage6.ram_ra_virtual.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6InstructionRaVirtual, local_scalars: &[], expected_output: "stage6.instruction_ra_virtual.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6IncClaimReduction, local_scalars: &[], expected_output: "stage6.inc_claim_reduction.output.claim_expr" }, + Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" }, ]; pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { @@ -697,7 +680,6 @@ pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { drivers: STAGE6_SUMCHECK_DRIVERS, instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS, evals: STAGE6_SUMCHECK_EVALS, - relation_output_values: STAGE6_RELATION_OUTPUT_VALUES, relation_outputs: STAGE6_RELATION_OUTPUTS, point_exprs: STAGE6_POINT_EXPRS, opening_claims: STAGE6_OPENING_CLAIMS, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 1533f67013..8845603fa0 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -16,7 +16,6 @@ pub type Stage7SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage7SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; pub type Stage7RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; -pub type Stage7StructuredPolynomialEvalPlan = bolt_verifier_runtime::StructuredPolynomialEvalPlan; pub use super::jolt_relations::JoltRelationKind as Stage7RelationKind; pub use bolt_verifier_runtime::{ @@ -34,11 +33,6 @@ pub use bolt_verifier_runtime::{ StageParams as Stage7Params, SumcheckBatchPlan as Stage7SumcheckBatchPlan, SumcheckEvalPlan as Stage7SumcheckEvalPlan, - StructuredPolynomialKind as Stage7StructuredPolynomialKind, - StructuredPolynomialPointLength as Stage7StructuredPolynomialPointLength, - StructuredPolynomialPointOrder as Stage7StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, - StructuredPolynomialPointSegment as Stage7StructuredPolynomialPointSegment, TranscriptAbsorbBytesPlan as Stage7TranscriptAbsorbBytesPlan, TranscriptSqueezeKind as Stage7TranscriptSqueezeKind, TranscriptSqueezePlan as Stage7TranscriptSqueezePlan, @@ -200,93 +194,8 @@ pub const STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE: &[usize] = &[4]; pub const STAGE7_SUMCHECK_DRIVERS: &[Stage7SumcheckDriverPlan] = &[ Stage7SumcheckDriverPlan { symbol: "stage7.sumcheck", stage: "stage7", proof_slot: "stage7.sumcheck", kernel: None, relation: Some(Stage7RelationKind::Stage7Batched), batch: "stage7.batch", policy: "jolt_core_stage7_aligned", round_schedule: STAGE7_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 4, degree: 2 }, ]; -pub const STAGE7_RELATION_OUTPUT_VALUES: &[Stage7StructuredPolynomialEvalPlan] = &[ - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.booleanity.InstructionRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_1", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_2", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_3", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_4", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_5", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_6", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_7", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_8", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_9", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_10", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_11", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_12", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_13", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_14", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_15", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_16", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_17", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_18", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_19", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_20", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_21", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_22", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_23", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_24", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_25", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_26", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_27", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_28", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_29", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_30", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.instruction_ra_virtual.InstructionRa_31", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_1", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.bytecode_read_raf.BytecodeRa_2", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_0", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_1", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_2", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, - Stage7StructuredPolynomialEvalPlan { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", polynomial: Stage7StructuredPolynomialKind::Eq, x_point: Stage7StructuredPolynomialPointPlan { source: "stage7.hamming_weight_claim_reduction.instance", segment: Stage7StructuredPolynomialPointSegment::Full, length: Stage7StructuredPolynomialPointLength::Full, order: Stage7StructuredPolynomialPointOrder::Reverse }, y_point: Stage7StructuredPolynomialPointPlan { source: "stage7.input.stage6.ram_ra_virtual.RamRa_3", segment: Stage7StructuredPolynomialPointSegment::Prefix, length: Stage7StructuredPolynomialPointLength::XPoint, order: Stage7StructuredPolynomialPointOrder::AsIs } }, -]; - -pub const STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS: &[bolt_verifier_runtime::StructuredPolynomialEvalRef] = &[ - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.Booleanity", index: 0 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_0.virtualization", index: 1 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_1.virtualization", index: 2 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_2.virtualization", index: 3 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_3.virtualization", index: 4 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_4.virtualization", index: 5 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_5.virtualization", index: 6 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_6.virtualization", index: 7 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_7.virtualization", index: 8 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_8.virtualization", index: 9 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_9.virtualization", index: 10 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_10.virtualization", index: 11 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_11.virtualization", index: 12 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_12.virtualization", index: 13 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_13.virtualization", index: 14 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_14.virtualization", index: 15 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_15.virtualization", index: 16 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_16.virtualization", index: 17 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_17.virtualization", index: 18 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_18.virtualization", index: 19 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_19.virtualization", index: 20 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_20.virtualization", index: 21 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_21.virtualization", index: 22 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_22.virtualization", index: 23 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_23.virtualization", index: 24 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_24.virtualization", index: 25 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_25.virtualization", index: 26 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_26.virtualization", index: 27 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_27.virtualization", index: 28 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_28.virtualization", index: 29 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_29.virtualization", index: 30 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_30.virtualization", index: 31 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.InstructionRa_31.virtualization", index: 32 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_0.virtualization", index: 33 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_1.virtualization", index: 34 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.BytecodeRa_2.virtualization", index: 35 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_0.virtualization", index: 36 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_1.virtualization", index: 37 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_2.virtualization", index: 38 }, - bolt_verifier_runtime::StructuredPolynomialEvalRef { symbol: "stage7.hamming_weight_claim_reduction.output.eq.RamRa_3.virtualization", index: 39 }, -]; pub const STAGE7_RELATION_OUTPUTS: &[Stage7RelationOutputPlan] = &[ - Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, structured_polynomial_evals: STAGE7_RELATION_OUTPUT_0_STRUCTURED_POLYNOMIAL_EVALS, local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.claim_expr" }, + Stage7RelationOutputPlan { relation: Stage7RelationKind::Stage7HammingWeightClaimReduction, local_scalars: &[], expected_output: "stage7.hamming_weight_claim_reduction.output.claim_expr" }, ]; pub const STAGE7_SUMCHECK_INSTANCE_RESULTS: &[Stage7SumcheckInstanceResultPlan] = &[ @@ -381,7 +290,6 @@ pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan { drivers: STAGE7_SUMCHECK_DRIVERS, instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS, evals: STAGE7_SUMCHECK_EVALS, - relation_output_values: STAGE7_RELATION_OUTPUT_VALUES, relation_outputs: STAGE7_RELATION_OUTPUTS, point_exprs: STAGE7_POINT_EXPRS, opening_claims: STAGE7_OPENING_CLAIMS, From 2117250cea47cc347d70201d18a03a91f7cf6777 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 01:05:52 -0600 Subject: [PATCH 117/171] refactor(bolt): remove relation output eval refs --- .../src/protocols/jolt/emit/rust/stage5.rs | 7 +--- .../jolt/stage5_instruction_read_raf_plan.rs | 15 +++----- .../jolt/stage6_bytecode_read_raf_plan.rs | 2 -- .../jolt/verifier_relation_outputs.rs | 34 +++++-------------- crates/bolt/tests/commitment_ir.rs | 10 +++--- 5 files changed, 18 insertions(+), 50 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 0ef4d6566d..213dd0e4b1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -702,11 +702,6 @@ impl Stage5CpuProgram { let output_plan = Stage5InstructionReadRafEmitPlan::from_eval_families(&indexed_eval_families)? .relation_output_plan(); - let relation_output_value_base = relation_output_values.len(); - let mut output_claim = output_plan.claim; - for value_ref in &mut output_claim.structured_polynomial_evals { - value_ref.index += relation_output_value_base; - } relation_output_values.extend(output_plan.relation_output_values); for expr in output_plan.field_exprs { if ScalarExprKind::from_cpu_attr(&expr.formula).is_ok() { @@ -715,7 +710,7 @@ impl Stage5CpuProgram { field_exprs.push(stage5_field_expr(expr)); } } - relation_outputs.push(output_claim); + relation_outputs.push(output_plan.claim); } if role == Role::Verifier { scalar_exprs.extend( diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 6b0a84738e..2894605969 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -1,9 +1,9 @@ use crate::emit::rust::{push_format, EmitError}; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_relation_outputs::{ - RelationOutputPlan, StructuredPolynomialEvalPlan, StructuredPolynomialEvalRefPlan, - StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, + RelationOutputPlan, StructuredPolynomialEvalPlan, StructuredPolynomialKind, + StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment, }; pub(crate) const STAGE5_TABLE_FLAG_EVAL_FAMILY: &str = @@ -203,10 +203,6 @@ impl Stage5InstructionReadRafEmitPlan { field_exprs, claim: RelationOutputPlan { relation: "jolt.stage5.instruction_read_raf".to_owned(), - structured_polynomial_evals: vec![StructuredPolynomialEvalRefPlan { - symbol: eq.symbol, - index: 0, - }], eval_families: Vec::new(), product_families: Vec::new(), local_scalars: self @@ -438,12 +434,11 @@ mod tests { output_plan.claim.expected_output, "stage5.instruction_read_raf.output.claim_expr" ); - assert_eq!(output_plan.claim.structured_polynomial_evals.len(), 1); + assert_eq!(output_plan.relation_output_values.len(), 1); assert_eq!( - output_plan.claim.structured_polynomial_evals[0].symbol, + output_plan.relation_output_values[0].symbol, "stage5.instruction_read_raf.output.eq.LookupOutputCycle" ); - assert_eq!(output_plan.claim.structured_polynomial_evals[0].index, 0); assert!(output_plan.claim.product_families.is_empty()); assert_eq!( output_plan.claim.local_scalars, diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 354f1c52f4..63e1699c58 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -370,7 +370,6 @@ impl BytecodeReadRafPlan { ], claim: RelationOutputPlan { relation: "jolt.stage6.bytecode_read_raf".to_owned(), - structured_polynomial_evals: Vec::new(), eval_families: Vec::new(), product_families: Vec::new(), local_scalars: vec![self.output_contribution.to_owned()], @@ -694,7 +693,6 @@ mod tests { claim.expected_output, "stage6.bytecode_read_raf.output.claim_expr" ); - assert!(claim.structured_polynomial_evals.is_empty()); assert!(claim.eval_families.is_empty()); assert!(claim.product_families.is_empty()); assert_eq!( diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 0c7127d38f..ef43ed57da 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -196,12 +196,6 @@ impl StructuredPolynomialEvalPlan { } } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct StructuredPolynomialEvalRefPlan { - pub symbol: String, - pub index: usize, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputEvalFamilySharedTermPlan { pub gamma_power_offset: usize, @@ -258,7 +252,6 @@ pub struct RelationOutputFunctionFamilyPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: String, - pub structured_polynomial_evals: Vec, pub eval_families: Vec, pub product_families: Vec, pub local_scalars: Vec, @@ -1026,24 +1019,14 @@ where claim.relation ))); } - let structured_polynomial_evals = claim - .polynomial_evals - .iter() - .map(|symbol| { - relation_output_values_by_symbol - .get(symbol.as_str()) - .map(|&index| StructuredPolynomialEvalRefPlan { - symbol: symbol.clone(), - index, - }) - .ok_or_else(|| { - EmitError::new(format!( - "{stage} relation output for @{} references missing output value @{symbol}", - claim.relation - )) - }) - }) - .collect::, EmitError>>()?; + for symbol in &claim.polynomial_evals { + if !relation_output_values_by_symbol.contains_key(symbol.as_str()) { + return Err(EmitError::new(format!( + "{stage} relation output for @{} references missing output value @{symbol}", + claim.relation + ))); + } + } let dependencies = output_dependency_closure( &relation_output_eval_families_by_symbol, &relation_output_product_families_by_symbol, @@ -1062,7 +1045,6 @@ where .collect(); Ok(RelationOutputPlan { relation: claim.relation, - structured_polynomial_evals, eval_families, product_families, local_scalars: Vec::new(), diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 68a5cf4eee..9d4c35ce0c 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1732,11 +1732,10 @@ fn stage6_rust_targets_extract_and_compile() { assert_eq!(booleanity_claims.len(), 1); assert!(booleanity_claims[0].eval_families.is_empty()); assert!(booleanity_claims[0].product_families.is_empty()); - assert_eq!( - booleanity_claims[0].structured_polynomial_evals[0].symbol, - "stage6.booleanity.output.eq.InstructionRa0" - ); - assert_eq!(booleanity_claims[0].structured_polynomial_evals[0].index, 0); + assert!(verifier_program + .scalar_exprs + .iter() + .any(|expr| expr.symbol == "stage6.booleanity.output.eq.InstructionRa0")); let hamming_claims = verifier_program .relation_outputs .iter() @@ -1767,7 +1766,6 @@ fn stage6_rust_targets_extract_and_compile() { .filter(|claim| claim.expected_output == "stage6.bytecode_read_raf.output.claim_expr") .collect::>(); assert_eq!(bytecode_claims.len(), 1); - assert!(bytecode_claims[0].structured_polynomial_evals.is_empty()); assert!(bytecode_claims[0].eval_families.is_empty()); assert!(bytecode_claims[0].product_families.is_empty()); let bytecode_output_scalar_exprs = verifier_program From 8dfe7e8b2cf791d740f62c8d19ec17e1bfeefa2b Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 01:13:31 -0600 Subject: [PATCH 118/171] refactor(bolt): require lowered relation outputs --- .../jolt/emit/rust/relation_outputs.rs | 12 --- .../src/protocols/jolt/emit/rust/stage5.rs | 12 --- .../src/protocols/jolt/emit/rust/stage6.rs | 12 --- .../jolt/stage5_instruction_read_raf_plan.rs | 3 - .../jolt/stage6_bytecode_read_raf_plan.rs | 4 - .../bolt/src/protocols/jolt/verifier_plan.rs | 12 --- .../jolt/verifier_relation_outputs.rs | 97 ++++++++++--------- crates/bolt/tests/commitment_ir.rs | 15 --- 8 files changed, 49 insertions(+), 118 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index cba0ad4827..85954e1933 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -10,18 +10,6 @@ pub fn emit_verifier_relation_output_constants( let mut source = String::new(); let mut claims = Vec::new(); for (index, claim) in relation_outputs.iter().enumerate() { - if let Some(family) = claim.eval_families.first() { - return Err(EmitError::new(format!( - "{stage_type} relation output eval family @{} must be lowered before Rust verifier emission", - family.symbol - ))); - } - if let Some(family) = claim.product_families.first() { - return Err(EmitError::new(format!( - "{stage_type} relation output product family @{} must be lowered before Rust verifier emission", - family.symbol - ))); - } let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim); claims.push(format!( " {stage_type}RelationOutputPlan {{ relation: {}, local_scalars: {local_scalars}, expected_output: {} }},", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 213dd0e4b1..ddae97a86e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -911,18 +911,6 @@ impl Stage5CpuProgram { .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), - verifier_values::VerifierScalarSourceKind::OutputEvalFamily, - ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), - verifier_values::VerifierScalarSourceKind::OutputProductFamily, - ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), verifier_values::VerifierScalarSourceKind::FieldExpr, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 19eb922912..2f927f749b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -926,18 +926,6 @@ impl Stage6CpuProgram { .map(|family| &family.symbol), verifier_values::VerifierScalarSourceKind::OutputFunctionFamily, ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), - verifier_values::VerifierScalarSourceKind::OutputEvalFamily, - ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), - verifier_values::VerifierScalarSourceKind::OutputProductFamily, - ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), verifier_values::VerifierScalarSourceKind::FieldExpr, diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 2894605969..730026123e 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -203,8 +203,6 @@ impl Stage5InstructionReadRafEmitPlan { field_exprs, claim: RelationOutputPlan { relation: "jolt.stage5.instruction_read_raf".to_owned(), - eval_families: Vec::new(), - product_families: Vec::new(), local_scalars: self .point_values .iter() @@ -439,7 +437,6 @@ mod tests { output_plan.relation_output_values[0].symbol, "stage5.instruction_read_raf.output.eq.LookupOutputCycle" ); - assert!(output_plan.claim.product_families.is_empty()); assert_eq!( output_plan.claim.local_scalars, vec![ diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 63e1699c58..abea07851f 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -370,8 +370,6 @@ impl BytecodeReadRafPlan { ], claim: RelationOutputPlan { relation: "jolt.stage6.bytecode_read_raf".to_owned(), - eval_families: Vec::new(), - product_families: Vec::new(), local_scalars: vec![self.output_contribution.to_owned()], expected_output: claim_expr, }, @@ -693,8 +691,6 @@ mod tests { claim.expected_output, "stage6.bytecode_read_raf.output.claim_expr" ); - assert!(claim.eval_families.is_empty()); - assert!(claim.product_families.is_empty()); assert_eq!( claim.local_scalars, vec![stage6_bytecode_read_raf_output_contribution_symbol().to_owned()] diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 6112fbdbfa..86b2564d80 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -328,18 +328,6 @@ impl VerifierStagePlan { .map(|family| &family.symbol), VerifierScalarSourceKind::OutputFunctionFamily, ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.eval_families.iter().map(|family| &family.symbol)), - VerifierScalarSourceKind::OutputEvalFamily, - ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.product_families.iter().map(|family| &family.symbol)), - VerifierScalarSourceKind::OutputProductFamily, - ); values.extend( self.field_exprs.iter().map(|expr| &expr.symbol), VerifierScalarSourceKind::FieldExpr, diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index ef43ed57da..960a392e38 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -252,8 +252,6 @@ pub struct RelationOutputFunctionFamilyPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: String, - pub eval_families: Vec, - pub product_families: Vec, pub local_scalars: Vec, pub expected_output: String, } @@ -1033,20 +1031,20 @@ where &field_exprs_by_symbol, std::iter::once(claim.expected_output.as_str()), ); - let eval_families = relation_output_eval_families - .iter() - .filter(|family| dependencies.contains_eval_family(&family.symbol)) - .cloned() - .collect(); - let product_families = relation_output_product_families - .iter() - .filter(|family| dependencies.contains_product_family(&family.symbol)) - .cloned() - .collect(); + if let Some(family) = dependencies.first_eval_family() { + return Err(EmitError::new(format!( + "{stage} relation output for @{} depends on unlowered eval family @{family}", + claim.relation + ))); + } + if let Some(family) = dependencies.first_product_family() { + return Err(EmitError::new(format!( + "{stage} relation output for @{} depends on unlowered product family @{family}", + claim.relation + ))); + } Ok(RelationOutputPlan { relation: claim.relation, - eval_families, - product_families, local_scalars: Vec::new(), expected_output: claim.expected_output, }) @@ -1074,16 +1072,18 @@ struct OutputDependencyClosure { } impl OutputDependencyClosure { - fn contains_eval_family(&self, symbol: &str) -> bool { - self.families - .iter() - .any(|family| matches!(family, OutputFamilyDependency::Eval(value) if value == symbol)) + fn first_eval_family(&self) -> Option<&str> { + self.families.iter().find_map(|family| match family { + OutputFamilyDependency::Eval(value) => Some(value.as_str()), + OutputFamilyDependency::Product(_) => None, + }) } - fn contains_product_family(&self, symbol: &str) -> bool { - self.families.iter().any( - |family| matches!(family, OutputFamilyDependency::Product(value) if value == symbol), - ) + fn first_product_family(&self) -> Option<&str> { + self.families.iter().find_map(|family| match family { + OutputFamilyDependency::Eval(_) => None, + OutputFamilyDependency::Product(value) => Some(value.as_str()), + }) } } @@ -1500,7 +1500,7 @@ mod tests { } #[test] - fn resolves_relation_output_eval_families_reachable_through_field_expressions( + fn resolve_rejects_unlowered_eval_families_reachable_through_field_expressions( ) -> Result<(), EmitError> { let inner_family = RelationOutputEvalFamilyPlan { symbol: "inner.family".to_owned(), @@ -1543,7 +1543,7 @@ mod tests { expected_output: "claim.expr".to_owned(), }]; - let claims = resolve_relation_outputs( + let error = match resolve_relation_outputs( "test", &[], &[inner_family, outer_family], @@ -1551,22 +1551,23 @@ mod tests { &[], &field_exprs, claim_asts, - )?; - let claim = claims - .first() - .ok_or_else(|| EmitError::new("missing resolved relation output"))?; - let family_symbols = claim - .eval_families - .iter() - .map(|family| family.symbol.as_str()) - .collect::>(); - assert_eq!(family_symbols, vec!["inner.family", "outer.family"]); - assert!(claim.product_families.is_empty()); + ) { + Ok(_) => { + return Err(EmitError::new( + "unlowered eval family should fail relation output resolution", + )); + } + Err(error) => error, + }; + assert!(error.to_string().contains( + "test relation output for @relation depends on unlowered eval family @inner.family" + )); Ok(()) } #[test] - fn resolves_product_families_reachable_through_field_expressions() -> Result<(), EmitError> { + fn resolve_rejects_unlowered_product_families_reachable_through_field_expressions( + ) -> Result<(), EmitError> { let product_family = RelationOutputProductFamilyPlan { symbol: "product.family".to_owned(), gamma: Some("product.gamma".to_owned()), @@ -1594,7 +1595,7 @@ mod tests { expected_output: "claim.expr".to_owned(), }]; - let claims = resolve_relation_outputs( + let error = match resolve_relation_outputs( "test", &[], &[], @@ -1602,17 +1603,17 @@ mod tests { &[], &field_exprs, claim_asts, - )?; - let claim = claims - .first() - .ok_or_else(|| EmitError::new("missing resolved relation output"))?; - assert!(claim.eval_families.is_empty()); - let family_symbols = claim - .product_families - .iter() - .map(|family| family.symbol.as_str()) - .collect::>(); - assert_eq!(family_symbols, vec!["product.family"]); + ) { + Ok(_) => { + return Err(EmitError::new( + "unlowered product family should fail relation output resolution", + )); + } + Err(error) => error, + }; + assert!(error.to_string().contains( + "test relation output for @relation depends on unlowered product family @product.family" + )); Ok(()) } diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 9d4c35ce0c..2430052146 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1722,16 +1722,12 @@ fn stage6_rust_targets_extract_and_compile() { .filter(|claim| claim.expected_output == "stage6.inc_claim_reduction.output.claim_expr") .collect::>(); assert_eq!(inc_claims.len(), 1); - assert!(inc_claims[0].eval_families.is_empty()); - assert!(inc_claims[0].product_families.is_empty()); let booleanity_claims = verifier_program .relation_outputs .iter() .filter(|claim| claim.expected_output == "stage6.booleanity.output.claim_expr") .collect::>(); assert_eq!(booleanity_claims.len(), 1); - assert!(booleanity_claims[0].eval_families.is_empty()); - assert!(booleanity_claims[0].product_families.is_empty()); assert!(verifier_program .scalar_exprs .iter() @@ -1742,32 +1738,24 @@ fn stage6_rust_targets_extract_and_compile() { .filter(|claim| claim.expected_output == "stage6.hamming_booleanity.output.claim_expr") .collect::>(); assert_eq!(hamming_claims.len(), 1); - assert!(hamming_claims[0].eval_families.is_empty()); - assert!(hamming_claims[0].product_families.is_empty()); let ram_ra_claims = verifier_program .relation_outputs .iter() .filter(|claim| claim.expected_output == "stage6.ram_ra_virtual.output.claim_expr") .collect::>(); assert_eq!(ram_ra_claims.len(), 1); - assert!(ram_ra_claims[0].eval_families.is_empty()); - assert!(ram_ra_claims[0].product_families.is_empty()); let instruction_ra_claims = verifier_program .relation_outputs .iter() .filter(|claim| claim.expected_output == "stage6.instruction_ra_virtual.output.claim_expr") .collect::>(); assert_eq!(instruction_ra_claims.len(), 1); - assert!(instruction_ra_claims[0].eval_families.is_empty()); - assert!(instruction_ra_claims[0].product_families.is_empty()); let bytecode_claims = verifier_program .relation_outputs .iter() .filter(|claim| claim.expected_output == "stage6.bytecode_read_raf.output.claim_expr") .collect::>(); assert_eq!(bytecode_claims.len(), 1); - assert!(bytecode_claims[0].eval_families.is_empty()); - assert!(bytecode_claims[0].product_families.is_empty()); let bytecode_output_scalar_exprs = verifier_program .scalar_exprs .iter() @@ -2069,9 +2057,6 @@ fn stage7_rust_targets_extract_and_compile() { assert_eq!(verifier_program.relation_output_values.len(), total_ra + 1); assert!(verifier_program.relation_output_eval_families.is_empty()); assert_eq!(verifier_program.relation_outputs.len(), 1); - assert!(verifier_program.relation_outputs[0] - .eval_families - .is_empty()); assert_eq!( verifier_program.relation_outputs[0].expected_output, "stage7.hamming_weight_claim_reduction.output.claim_expr" From 5d729a3b8d2ff1e42ddce11007eedf5acbc2a4f4 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 01:20:01 -0600 Subject: [PATCH 119/171] refactor(jolt): share projected identity evaluation --- .../jolt/verifier_jolt_relations.rs.template | 43 ++++++----- crates/jolt-poly/src/identity.rs | 76 +++++++++++++++++-- .../src/stages/jolt_relations.rs | 43 ++++++----- 3 files changed, 117 insertions(+), 45 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index e28cfba8a7..499df4629f 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -14,8 +14,8 @@ //! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement //! - typed bytecode read-RAF plan data and its small Jolt-specific evaluator //! - the small Jolt-specific field-math helpers -//! (`operand_polynomial_eval`, `identity_polynomial_eval`, -//! `bytecode_gamma_powers`) used only by Jolt verification +//! (`operand_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt +//! verification //! //! Treat changes here as Jolt protocol changes, not as compiler-output //! cleanups. Generic Bolt verifier scaffolding (typed plan structs, @@ -24,9 +24,9 @@ //! //! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition. -use jolt_field::{Field, Fr, MulPow2}; +use jolt_field::{Field, Fr}; use jolt_lookup_tables::LookupTableKind; -use jolt_poly::EqPolynomial; +use jolt_poly::{EqPolynomial, IdentityPolynomial}; use bolt_verifier_runtime::{ field_powers, prefix_point, store_point, store_scalar, suffix_point, NamedEvalFamilyPlan, @@ -248,13 +248,13 @@ fn evaluate_stage5_instruction_read_raf_point_value( table.evaluate_mle::(r_address_prime) } Stage5InstructionReadRafPointValueKind::LeftOperand => { - operand_polynomial_eval(r_address_prime, true) + operand_polynomial_eval(r_address_prime, true)? } Stage5InstructionReadRafPointValueKind::RightOperand => { - operand_polynomial_eval(r_address_prime, false) + operand_polynomial_eval(r_address_prime, false)? } Stage5InstructionReadRafPointValueKind::Identity => { - identity_polynomial_eval(r_address_prime) + IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime) } }) } @@ -357,7 +357,7 @@ fn stage67_bytecode_output_contribution( r_cycle_prime: &[Fr], log_k: usize, ) -> Result { - let int_eval = identity_polynomial_eval(r_address_prime); + let int_eval = IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime); let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; let entry_address_eq = EqPolynomial::::try_mle_at_boolean_index(entry_bytecode_index, r_address_prime).ok_or( @@ -682,18 +682,21 @@ fn stage67_register_prefix_point<'a>( prefix_point(point, register_len, symbol) } -pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Fr { +pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Result { let stride_offset = usize::from(!left); let operand_bits = point.len() / 2; - (0..operand_bits) - .map(|index| point[2 * index + stride_offset].mul_pow_2(operand_bits - 1 - index)) - .sum() -} - -pub fn identity_polynomial_eval(point: &[Fr]) -> Fr { - point - .iter() - .enumerate() - .map(|(index, value)| value.mul_pow_2(point.len() - 1 - index)) - .sum() + if point.len() != operand_bits * 2 { + return Err(RuntimePlanError::InvalidInputLength { + input: "stage5.instruction_read_raf.operand_point", + expected: operand_bits * 2, + actual: point.len(), + }); + } + IdentityPolynomial::new(operand_bits) + .try_evaluate_projected(point, stride_offset, 2) + .ok_or(RuntimePlanError::InvalidInputLength { + input: "stage5.instruction_read_raf.operand_point", + expected: operand_bits * 2, + actual: point.len(), + }) } diff --git a/crates/jolt-poly/src/identity.rs b/crates/jolt-poly/src/identity.rs index e2df04a5a1..8f0538de1d 100644 --- a/crates/jolt-poly/src/identity.rs +++ b/crates/jolt-poly/src/identity.rs @@ -24,6 +24,37 @@ impl IdentityPolynomial { self.num_vars } + pub fn try_evaluate(&self, point: &[F]) -> Option { + if point.len() != self.num_vars { + return None; + } + Some(evaluate_identity(point.iter().copied(), self.num_vars)) + } + + pub fn try_evaluate_projected( + &self, + point: &[F], + offset: usize, + stride: usize, + ) -> Option { + if self.num_vars == 0 { + return Some(F::zero()); + } + if stride == 0 { + return None; + } + let last_index = stride + .checked_mul(self.num_vars - 1) + .and_then(|last_offset| offset.checked_add(last_offset))?; + if last_index >= point.len() { + return None; + } + Some(evaluate_identity( + (0..self.num_vars).map(|index| point[offset + stride * index]), + self.num_vars, + )) + } + /// Evaluates $\widetilde{I}(r) = \sum_{i=1}^{n} r_i \cdot 2^{n-i}$. /// /// Time: $O(n)$. No heap allocation. @@ -34,14 +65,16 @@ impl IdentityPolynomial { self.num_vars, "point dimension must match num_vars" ); - let n = self.num_vars; - point - .iter() - .enumerate() - .fold(F::zero(), |acc, (i, &r_i)| acc + r_i.mul_pow_2(n - 1 - i)) + evaluate_identity(point.iter().copied(), self.num_vars) } } +fn evaluate_identity(values: impl Iterator, num_vars: usize) -> F { + values.enumerate().fold(F::zero(), |acc, (index, value)| { + acc + value.mul_pow_2(num_vars - 1 - index) + }) +} + impl crate::MultilinearEvaluation for IdentityPolynomial { fn num_vars(&self) -> usize { self.num_vars @@ -97,4 +130,37 @@ mod tests { assert!(id.evaluate(&[Fr::zero()]).is_zero()); assert_eq!(id.evaluate(&[Fr::one()]), Fr::one()); } + + #[test] + fn try_evaluate_rejects_dimension_mismatch() { + let id = IdentityPolynomial::new(2); + assert_eq!(id.try_evaluate::(&[Fr::one()]), None); + } + + #[test] + fn projected_identity_uses_offset_and_stride() { + let id = IdentityPolynomial::new(3); + let point = [ + Fr::from_u64(1), + Fr::from_u64(9), + Fr::from_u64(0), + Fr::from_u64(8), + Fr::from_u64(1), + ]; + + assert_eq!( + id.try_evaluate_projected(&point, 0, 2), + Some(Fr::from_u64(5)) + ); + } + + #[test] + fn projected_identity_rejects_out_of_range_projection() { + let id = IdentityPolynomial::new(3); + assert_eq!(id.try_evaluate_projected::(&[Fr::one()], 0, 2), None); + assert_eq!( + id.try_evaluate_projected::(&[Fr::one(), Fr::one()], 0, 0), + None + ); + } } diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index e28cfba8a7..499df4629f 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -14,8 +14,8 @@ //! - the `Stage67BytecodeEntry` contract a Jolt bytecode row must implement //! - typed bytecode read-RAF plan data and its small Jolt-specific evaluator //! - the small Jolt-specific field-math helpers -//! (`operand_polynomial_eval`, `identity_polynomial_eval`, -//! `bytecode_gamma_powers`) used only by Jolt verification +//! (`operand_polynomial_eval`, `bytecode_gamma_powers`) used only by Jolt +//! verification //! //! Treat changes here as Jolt protocol changes, not as compiler-output //! cleanups. Generic Bolt verifier scaffolding (typed plan structs, @@ -24,9 +24,9 @@ //! //! See `crates/bolt/GOAL.md` "Audit Tiers" for the full tier definition. -use jolt_field::{Field, Fr, MulPow2}; +use jolt_field::{Field, Fr}; use jolt_lookup_tables::LookupTableKind; -use jolt_poly::EqPolynomial; +use jolt_poly::{EqPolynomial, IdentityPolynomial}; use bolt_verifier_runtime::{ field_powers, prefix_point, store_point, store_scalar, suffix_point, NamedEvalFamilyPlan, @@ -248,13 +248,13 @@ fn evaluate_stage5_instruction_read_raf_point_value( table.evaluate_mle::(r_address_prime) } Stage5InstructionReadRafPointValueKind::LeftOperand => { - operand_polynomial_eval(r_address_prime, true) + operand_polynomial_eval(r_address_prime, true)? } Stage5InstructionReadRafPointValueKind::RightOperand => { - operand_polynomial_eval(r_address_prime, false) + operand_polynomial_eval(r_address_prime, false)? } Stage5InstructionReadRafPointValueKind::Identity => { - identity_polynomial_eval(r_address_prime) + IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime) } }) } @@ -357,7 +357,7 @@ fn stage67_bytecode_output_contribution( r_cycle_prime: &[Fr], log_k: usize, ) -> Result { - let int_eval = identity_polynomial_eval(r_address_prime); + let int_eval = IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime); let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; let entry_address_eq = EqPolynomial::::try_mle_at_boolean_index(entry_bytecode_index, r_address_prime).ok_or( @@ -682,18 +682,21 @@ fn stage67_register_prefix_point<'a>( prefix_point(point, register_len, symbol) } -pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Fr { +pub fn operand_polynomial_eval(point: &[Fr], left: bool) -> Result { let stride_offset = usize::from(!left); let operand_bits = point.len() / 2; - (0..operand_bits) - .map(|index| point[2 * index + stride_offset].mul_pow_2(operand_bits - 1 - index)) - .sum() -} - -pub fn identity_polynomial_eval(point: &[Fr]) -> Fr { - point - .iter() - .enumerate() - .map(|(index, value)| value.mul_pow_2(point.len() - 1 - index)) - .sum() + if point.len() != operand_bits * 2 { + return Err(RuntimePlanError::InvalidInputLength { + input: "stage5.instruction_read_raf.operand_point", + expected: operand_bits * 2, + actual: point.len(), + }); + } + IdentityPolynomial::new(operand_bits) + .try_evaluate_projected(point, stride_offset, 2) + .ok_or(RuntimePlanError::InvalidInputLength { + input: "stage5.instruction_read_raf.operand_point", + expected: operand_bits * 2, + actual: point.len(), + }) } From c763dc06ed67468fa706367b659c5d917a054cbf Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 01:30:22 -0600 Subject: [PATCH 120/171] refactor(bolt): split bytecode output terms --- .../jolt/stage6_bytecode_read_raf_plan.rs | 81 ++++++++++++++++--- .../jolt/verifier_jolt_relations.rs.template | 47 +++++++---- .../src/stages/jolt_relations.rs | 47 +++++++---- crates/jolt-verifier/src/stages/stage6.rs | 16 ++-- 4 files changed, 140 insertions(+), 51 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index abea07851f..8cc8d0dcea 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -34,15 +34,25 @@ pub(crate) struct BytecodeReadRafStagePlan { #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum BytecodeOutputTermPlan { StageValue { + symbol: &'static str, stage_index: usize, gamma_power: usize, identity_gamma_power: Option, }, Entry { + symbol: &'static str, gamma_power: usize, }, } +impl BytecodeOutputTermPlan { + fn symbol(self) -> &'static str { + match self { + Self::StageValue { symbol, .. } | Self::Entry { symbol, .. } => symbol, + } + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) struct BytecodeRegisterSymbols { pub(crate) rd: &'static str, @@ -281,31 +291,39 @@ const STAGE6_BYTECODE_STAGES: &[BytecodeReadRafStagePlan] = &[ const STAGE6_BYTECODE_OUTPUT_TERMS: &[BytecodeOutputTermPlan] = &[ BytecodeOutputTermPlan::StageValue { + symbol: "stage6.bytecode_read_raf.output.term.Stage1", stage_index: 0, gamma_power: 0, identity_gamma_power: Some(5), }, BytecodeOutputTermPlan::StageValue { + symbol: "stage6.bytecode_read_raf.output.term.Stage2", stage_index: 1, gamma_power: 1, identity_gamma_power: None, }, BytecodeOutputTermPlan::StageValue { + symbol: "stage6.bytecode_read_raf.output.term.Stage3", stage_index: 2, gamma_power: 2, identity_gamma_power: Some(4), }, BytecodeOutputTermPlan::StageValue { + symbol: "stage6.bytecode_read_raf.output.term.Stage4", stage_index: 3, gamma_power: 3, identity_gamma_power: None, }, BytecodeOutputTermPlan::StageValue { + symbol: "stage6.bytecode_read_raf.output.term.Stage5", stage_index: 4, gamma_power: 4, identity_gamma_power: None, }, - BytecodeOutputTermPlan::Entry { gamma_power: 7 }, + BytecodeOutputTermPlan::Entry { + symbol: "stage6.bytecode_read_raf.output.term.Entry", + gamma_power: 7, + }, ]; const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { @@ -355,6 +373,13 @@ impl BytecodeReadRafPlan { ) -> Stage6BytecodeReadRafRelationOutputPlan { let bytecode_ra_product = "stage6.bytecode_read_raf.output.product.BytecodeRa".to_owned(); let claim_expr = "stage6.bytecode_read_raf.output.claim_expr".to_owned(); + let output_term_symbols = self + .output_terms + .iter() + .copied() + .map(BytecodeOutputTermPlan::symbol) + .map(str::to_owned) + .collect::>(); Stage6BytecodeReadRafRelationOutputPlan { field_exprs: vec![ RelationOutputFieldExprPlan { @@ -362,6 +387,11 @@ impl BytecodeReadRafPlan { formula: "field_vector.product".to_owned(), operands: vec![bytecode_ra_evals.symbol.clone()], }, + RelationOutputFieldExprPlan { + symbol: self.output_contribution.to_owned(), + formula: "field.sum".to_owned(), + operands: output_term_symbols.clone(), + }, RelationOutputFieldExprPlan { symbol: claim_expr.clone(), formula: "field.product".to_owned(), @@ -370,7 +400,7 @@ impl BytecodeReadRafPlan { ], claim: RelationOutputPlan { relation: "jolt.stage6.bytecode_read_raf".to_owned(), - local_scalars: vec![self.output_contribution.to_owned()], + local_scalars: output_term_symbols, expected_output: claim_expr, }, } @@ -520,15 +550,23 @@ fn emit_bytecode_read_raf_term_plan(term: &BytecodeReadRafTermPlan) -> String { fn emit_bytecode_output_term_plan(term: &BytecodeOutputTermPlan) -> String { match *term { BytecodeOutputTermPlan::StageValue { + symbol, stage_index, gamma_power, identity_gamma_power, } => format!( - "Stage67BytecodeOutputTermPlan::StageValue {{ stage_index: {stage_index}, gamma_power: {gamma_power}, identity_gamma_power: {} }}", + "Stage67BytecodeOutputTermPlan::StageValue {{ symbol: {}, stage_index: {stage_index}, gamma_power: {gamma_power}, identity_gamma_power: {} }}", + rust_str(symbol), emit_option_usize(identity_gamma_power), ), - BytecodeOutputTermPlan::Entry { gamma_power } => { - format!("Stage67BytecodeOutputTermPlan::Entry {{ gamma_power: {gamma_power} }}") + BytecodeOutputTermPlan::Entry { + symbol, + gamma_power, + } => { + format!( + "Stage67BytecodeOutputTermPlan::Entry {{ symbol: {}, gamma_power: {gamma_power} }}", + rust_str(symbol) + ) } } } @@ -611,6 +649,7 @@ mod tests { assert_eq!( plan.output_terms[0], BytecodeOutputTermPlan::StageValue { + symbol: "stage6.bytecode_read_raf.output.term.Stage1", stage_index: 0, gamma_power: 0, identity_gamma_power: Some(5), @@ -618,7 +657,10 @@ mod tests { ); assert_eq!( plan.output_terms[5], - BytecodeOutputTermPlan::Entry { gamma_power: 7 } + BytecodeOutputTermPlan::Entry { + symbol: "stage6.bytecode_read_raf.output.term.Entry", + gamma_power: 7 + } ); assert_eq!( stage1.terms[0], @@ -693,16 +735,35 @@ mod tests { ); assert_eq!( claim.local_scalars, - vec![stage6_bytecode_read_raf_output_contribution_symbol().to_owned()] + vec![ + "stage6.bytecode_read_raf.output.term.Stage1".to_owned(), + "stage6.bytecode_read_raf.output.term.Stage2".to_owned(), + "stage6.bytecode_read_raf.output.term.Stage3".to_owned(), + "stage6.bytecode_read_raf.output.term.Stage4".to_owned(), + "stage6.bytecode_read_raf.output.term.Stage5".to_owned(), + "stage6.bytecode_read_raf.output.term.Entry".to_owned(), + ] ); assert_eq!(output_plan.field_exprs[0].formula, "field_vector.product"); assert_eq!( output_plan.field_exprs[0].operands, vec![STAGE6_BYTECODE_RA_EVAL_FAMILY.to_owned()] ); - assert_eq!(output_plan.field_exprs[1].formula, "field.product"); + assert_eq!(output_plan.field_exprs[1].formula, "field.sum"); assert_eq!( output_plan.field_exprs[1].operands, + vec![ + "stage6.bytecode_read_raf.output.term.Stage1".to_owned(), + "stage6.bytecode_read_raf.output.term.Stage2".to_owned(), + "stage6.bytecode_read_raf.output.term.Stage3".to_owned(), + "stage6.bytecode_read_raf.output.term.Stage4".to_owned(), + "stage6.bytecode_read_raf.output.term.Stage5".to_owned(), + "stage6.bytecode_read_raf.output.term.Entry".to_owned(), + ] + ); + assert_eq!(output_plan.field_exprs[2].formula, "field.product"); + assert_eq!( + output_plan.field_exprs[2].operands, vec![ stage6_bytecode_read_raf_output_contribution_symbol().to_owned(), "stage6.bytecode_read_raf.output.product.BytecodeRa".to_owned() @@ -722,7 +783,9 @@ mod tests { assert!(!source.contains("STAGE6_BYTECODE_RA_EVAL_NAMES")); assert!(!source.contains("STAGE6_BYTECODE_RA_EVALS")); assert!(source.contains("const STAGE6_BYTECODE_OUTPUT_TERMS")); - assert!(source.contains("Stage67BytecodeOutputTermPlan::Entry { gamma_power: 7 }")); + assert!(source.contains( + "Stage67BytecodeOutputTermPlan::Entry { symbol: \"stage6.bytecode_read_raf.output.term.Entry\", gamma_power: 7 }" + )); assert!(source .contains("output_contribution: \"stage6.bytecode_read_raf.output.contribution\"")); assert!(source.contains("bytecode_ra_evals: &STAGE6_INDEXED_EVAL_FAMILIES[0]")); diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 499df4629f..ac949a04dc 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -137,15 +137,25 @@ pub struct Stage67BytecodeStagePlan { #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Stage67BytecodeOutputTermPlan { StageValue { + symbol: &'static str, stage_index: usize, gamma_power: usize, identity_gamma_power: Option, }, Entry { + symbol: &'static str, gamma_power: usize, }, } +impl Stage67BytecodeOutputTermPlan { + fn symbol(self) -> &'static str { + match self { + Self::StageValue { symbol, .. } | Self::Entry { symbol, .. } => symbol, + } + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage67BytecodeRegisterSymbols { pub rd: &'static str, @@ -295,7 +305,7 @@ pub fn evaluate_stage67_bytecode_read_raf_output_scalars Result>, RuntimePlanError> { - let output = stage67_bytecode_read_raf_output_contribution( + stage67_bytecode_read_raf_output_terms( plan, entries, entry_bytecode_index, @@ -303,14 +313,10 @@ pub fn evaluate_stage67_bytecode_read_raf_output_scalars( +fn stage67_bytecode_read_raf_output_terms( plan: &Stage67BytecodeReadRafPlan, entries: &[E], entry_bytecode_index: usize, @@ -318,7 +324,7 @@ fn stage67_bytecode_read_raf_output_contribution( store: &ValueStore, local_point: &[Fr], log_t: usize, -) -> Result { +) -> Result>, RuntimePlanError> { let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, plan.point)?; let log_k = opening_point.len() - log_t; let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k); @@ -334,7 +340,7 @@ fn stage67_bytecode_read_raf_output_contribution( r_address_prime, r_cycle_prime.len(), )?; - let output_contrib = stage67_bytecode_output_contribution( + stage67_bytecode_output_terms( plan, store, &stage_value_evals, @@ -343,11 +349,10 @@ fn stage67_bytecode_read_raf_output_contribution( r_address_prime, r_cycle_prime, log_k, - )?; - Ok(output_contrib) + ) } -fn stage67_bytecode_output_contribution( +fn stage67_bytecode_output_terms( plan: &Stage67BytecodeReadRafPlan, store: &ValueStore, stage_value_evals: &[Fr], @@ -356,7 +361,7 @@ fn stage67_bytecode_output_contribution( r_address_prime: &[Fr], r_cycle_prime: &[Fr], log_k: usize, -) -> Result { +) -> Result>, RuntimePlanError> { let int_eval = IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime); let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; let entry_address_eq = @@ -368,10 +373,11 @@ fn stage67_bytecode_output_contribution( }, )?; - let mut output = Fr::from_u64(0); + let mut output_terms = Vec::with_capacity(plan.output_terms.len()); for term in plan.output_terms { - output += match *term { + let value = match *term { Stage67BytecodeOutputTermPlan::StageValue { + symbol: _, stage_index, gamma_power, identity_gamma_power, @@ -399,14 +405,21 @@ fn stage67_bytecode_output_contribution( * EqPolynomial::::mle(&cycle_point, r_cycle_prime) * gamma_powers[gamma_power] } - Stage67BytecodeOutputTermPlan::Entry { gamma_power } => { + Stage67BytecodeOutputTermPlan::Entry { + symbol: _, + gamma_power, + } => { gamma_powers[gamma_power] * entry_address_eq * EqPolynomial::::mle(&zero_cycle, r_cycle_prime) } }; + output_terms.push(NamedScalar { + symbol: (*term).symbol(), + value, + }); } - Ok(output) + Ok(output_terms) } fn stage67_bytecode_stage_cycle_point( diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 499df4629f..ac949a04dc 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -137,15 +137,25 @@ pub struct Stage67BytecodeStagePlan { #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Stage67BytecodeOutputTermPlan { StageValue { + symbol: &'static str, stage_index: usize, gamma_power: usize, identity_gamma_power: Option, }, Entry { + symbol: &'static str, gamma_power: usize, }, } +impl Stage67BytecodeOutputTermPlan { + fn symbol(self) -> &'static str { + match self { + Self::StageValue { symbol, .. } | Self::Entry { symbol, .. } => symbol, + } + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Stage67BytecodeRegisterSymbols { pub rd: &'static str, @@ -295,7 +305,7 @@ pub fn evaluate_stage67_bytecode_read_raf_output_scalars Result>, RuntimePlanError> { - let output = stage67_bytecode_read_raf_output_contribution( + stage67_bytecode_read_raf_output_terms( plan, entries, entry_bytecode_index, @@ -303,14 +313,10 @@ pub fn evaluate_stage67_bytecode_read_raf_output_scalars( +fn stage67_bytecode_read_raf_output_terms( plan: &Stage67BytecodeReadRafPlan, entries: &[E], entry_bytecode_index: usize, @@ -318,7 +324,7 @@ fn stage67_bytecode_read_raf_output_contribution( store: &ValueStore, local_point: &[Fr], log_t: usize, -) -> Result { +) -> Result>, RuntimePlanError> { let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, plan.point)?; let log_k = opening_point.len() - log_t; let (r_address_prime, r_cycle_prime) = opening_point.split_at(log_k); @@ -334,7 +340,7 @@ fn stage67_bytecode_read_raf_output_contribution( r_address_prime, r_cycle_prime.len(), )?; - let output_contrib = stage67_bytecode_output_contribution( + stage67_bytecode_output_terms( plan, store, &stage_value_evals, @@ -343,11 +349,10 @@ fn stage67_bytecode_read_raf_output_contribution( r_address_prime, r_cycle_prime, log_k, - )?; - Ok(output_contrib) + ) } -fn stage67_bytecode_output_contribution( +fn stage67_bytecode_output_terms( plan: &Stage67BytecodeReadRafPlan, store: &ValueStore, stage_value_evals: &[Fr], @@ -356,7 +361,7 @@ fn stage67_bytecode_output_contribution( r_address_prime: &[Fr], r_cycle_prime: &[Fr], log_k: usize, -) -> Result { +) -> Result>, RuntimePlanError> { let int_eval = IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime); let zero_cycle = vec![Fr::from_u64(0); r_cycle_prime.len()]; let entry_address_eq = @@ -368,10 +373,11 @@ fn stage67_bytecode_output_contribution( }, )?; - let mut output = Fr::from_u64(0); + let mut output_terms = Vec::with_capacity(plan.output_terms.len()); for term in plan.output_terms { - output += match *term { + let value = match *term { Stage67BytecodeOutputTermPlan::StageValue { + symbol: _, stage_index, gamma_power, identity_gamma_power, @@ -399,14 +405,21 @@ fn stage67_bytecode_output_contribution( * EqPolynomial::::mle(&cycle_point, r_cycle_prime) * gamma_powers[gamma_power] } - Stage67BytecodeOutputTermPlan::Entry { gamma_power } => { + Stage67BytecodeOutputTermPlan::Entry { + symbol: _, + gamma_power, + } => { gamma_powers[gamma_power] * entry_address_eq * EqPolynomial::::mle(&zero_cycle, r_cycle_prime) } }; + output_terms.push(NamedScalar { + symbol: (*term).symbol(), + value, + }); } - Ok(output) + Ok(output_terms) } fn stage67_bytecode_stage_cycle_point( diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 2e16a82747..3ffb24191d 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -312,7 +312,7 @@ pub const STAGE6_FIELD_EXPRS: &[Stage6FieldExprPlan] = &[ stage6_field_expr("stage6.hamming_booleanity.output.term0", Stage6FieldExprKind::Product, &["stage6.hamming_booleanity.output.term0.boolean_zero", "stage6.hamming_booleanity.output.eq.LookupOutput"]), stage6_field_expr("stage6.hamming_booleanity.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.hamming_booleanity.output.term0"]), stage6_field_expr("stage6.inc_claim_reduction.output.term0", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.eq.RamIncStage2"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term1", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RamInc", "stage6.inc_claim_reduction.output.gamma_pow_1", "stage6.inc_claim_reduction.output.eq.RamIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term2", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_2", "stage6.inc_claim_reduction.output.eq.RdIncStage4"]), stage6_field_expr("stage6.inc_claim_reduction.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.inc_claim_reduction.gamma"]), stage6_field_expr("stage6.inc_claim_reduction.output.term3", Stage6FieldExprKind::Product, &["stage6.inc_claim_reduction.eval.RdInc", "stage6.inc_claim_reduction.output.gamma_pow_3", "stage6.inc_claim_reduction.output.eq.RdIncStage5"]), stage6_field_expr("stage6.inc_claim_reduction.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.inc_claim_reduction.output.term0", "stage6.inc_claim_reduction.output.term1", "stage6.inc_claim_reduction.output.term2", "stage6.inc_claim_reduction.output.term3"]), stage6_field_expr("stage6.ram_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.ram_ra_virtual.eval.RamRa_0", "stage6.ram_ra_virtual.eval.RamRa_1", "stage6.ram_ra_virtual.eval.RamRa_2", "stage6.ram_ra_virtual.eval.RamRa_3", "stage6.ram_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.ram_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.ram_ra_virtual.output.term0"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term0", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.eval.InstructionRa_0", "stage6.instruction_ra_virtual.eval.InstructionRa_1", "stage6.instruction_ra_virtual.eval.InstructionRa_2", "stage6.instruction_ra_virtual.eval.InstructionRa_3", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_1", Stage6FieldExprKind::Pow(1), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term1", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_1", "stage6.instruction_ra_virtual.eval.InstructionRa_4", "stage6.instruction_ra_virtual.eval.InstructionRa_5", "stage6.instruction_ra_virtual.eval.InstructionRa_6", "stage6.instruction_ra_virtual.eval.InstructionRa_7", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_2", Stage6FieldExprKind::Pow(2), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term2", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_2", "stage6.instruction_ra_virtual.eval.InstructionRa_8", "stage6.instruction_ra_virtual.eval.InstructionRa_9", "stage6.instruction_ra_virtual.eval.InstructionRa_10", "stage6.instruction_ra_virtual.eval.InstructionRa_11", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_3", Stage6FieldExprKind::Pow(3), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term3", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_3", "stage6.instruction_ra_virtual.eval.InstructionRa_12", "stage6.instruction_ra_virtual.eval.InstructionRa_13", "stage6.instruction_ra_virtual.eval.InstructionRa_14", "stage6.instruction_ra_virtual.eval.InstructionRa_15", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_4", Stage6FieldExprKind::Pow(4), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term4", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_4", "stage6.instruction_ra_virtual.eval.InstructionRa_16", "stage6.instruction_ra_virtual.eval.InstructionRa_17", "stage6.instruction_ra_virtual.eval.InstructionRa_18", "stage6.instruction_ra_virtual.eval.InstructionRa_19", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_5", Stage6FieldExprKind::Pow(5), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term5", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_5", "stage6.instruction_ra_virtual.eval.InstructionRa_20", "stage6.instruction_ra_virtual.eval.InstructionRa_21", "stage6.instruction_ra_virtual.eval.InstructionRa_22", "stage6.instruction_ra_virtual.eval.InstructionRa_23", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_6", Stage6FieldExprKind::Pow(6), &["stage6.instruction_ra_virtual.gamma"]), - stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), stage6_field_expr("stage6.bytecode_read_raf.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.output.product.BytecodeRa"]), + stage6_field_expr("stage6.instruction_ra_virtual.output.term6", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_6", "stage6.instruction_ra_virtual.eval.InstructionRa_24", "stage6.instruction_ra_virtual.eval.InstructionRa_25", "stage6.instruction_ra_virtual.eval.InstructionRa_26", "stage6.instruction_ra_virtual.eval.InstructionRa_27", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.gamma_pow_7", Stage6FieldExprKind::Pow(7), &["stage6.instruction_ra_virtual.gamma"]), stage6_field_expr("stage6.instruction_ra_virtual.output.term7", Stage6FieldExprKind::Product, &["stage6.instruction_ra_virtual.output.gamma_pow_7", "stage6.instruction_ra_virtual.eval.InstructionRa_28", "stage6.instruction_ra_virtual.eval.InstructionRa_29", "stage6.instruction_ra_virtual.eval.InstructionRa_30", "stage6.instruction_ra_virtual.eval.InstructionRa_31", "stage6.instruction_ra_virtual.output.eq.Cycle"]), stage6_field_expr("stage6.instruction_ra_virtual.output.claim_expr", Stage6FieldExprKind::Sum, &["stage6.instruction_ra_virtual.output.term0", "stage6.instruction_ra_virtual.output.term1", "stage6.instruction_ra_virtual.output.term2", "stage6.instruction_ra_virtual.output.term3", "stage6.instruction_ra_virtual.output.term4", "stage6.instruction_ra_virtual.output.term5", "stage6.instruction_ra_virtual.output.term6", "stage6.instruction_ra_virtual.output.term7"]), stage6_field_expr("stage6.bytecode_read_raf.output.contribution", Stage6FieldExprKind::Sum, &["stage6.bytecode_read_raf.output.term.Stage1", "stage6.bytecode_read_raf.output.term.Stage2", "stage6.bytecode_read_raf.output.term.Stage3", "stage6.bytecode_read_raf.output.term.Stage4", "stage6.bytecode_read_raf.output.term.Stage5", "stage6.bytecode_read_raf.output.term.Entry"]), stage6_field_expr("stage6.bytecode_read_raf.output.claim_expr", Stage6FieldExprKind::Product, &["stage6.bytecode_read_raf.output.contribution", "stage6.bytecode_read_raf.output.product.BytecodeRa"]), ]; const fn stage6_scalar_expr(symbol: &'static str, kind: Stage6ScalarExprKind, operands: &'static [&'static str]) -> Stage6ScalarExprPlan { Stage6ScalarExprPlan { symbol, kind, operands } @@ -630,12 +630,12 @@ const STAGE6_BYTECODE_STAGES: &[Stage67BytecodeStagePlan] = &[ ]; const STAGE6_BYTECODE_OUTPUT_TERMS: &[Stage67BytecodeOutputTermPlan] = &[ - Stage67BytecodeOutputTermPlan::StageValue { stage_index: 0, gamma_power: 0, identity_gamma_power: Some(5) }, - Stage67BytecodeOutputTermPlan::StageValue { stage_index: 1, gamma_power: 1, identity_gamma_power: None }, - Stage67BytecodeOutputTermPlan::StageValue { stage_index: 2, gamma_power: 2, identity_gamma_power: Some(4) }, - Stage67BytecodeOutputTermPlan::StageValue { stage_index: 3, gamma_power: 3, identity_gamma_power: None }, - Stage67BytecodeOutputTermPlan::StageValue { stage_index: 4, gamma_power: 4, identity_gamma_power: None }, - Stage67BytecodeOutputTermPlan::Entry { gamma_power: 7 }, + Stage67BytecodeOutputTermPlan::StageValue { symbol: "stage6.bytecode_read_raf.output.term.Stage1", stage_index: 0, gamma_power: 0, identity_gamma_power: Some(5) }, + Stage67BytecodeOutputTermPlan::StageValue { symbol: "stage6.bytecode_read_raf.output.term.Stage2", stage_index: 1, gamma_power: 1, identity_gamma_power: None }, + Stage67BytecodeOutputTermPlan::StageValue { symbol: "stage6.bytecode_read_raf.output.term.Stage3", stage_index: 2, gamma_power: 2, identity_gamma_power: Some(4) }, + Stage67BytecodeOutputTermPlan::StageValue { symbol: "stage6.bytecode_read_raf.output.term.Stage4", stage_index: 3, gamma_power: 3, identity_gamma_power: None }, + Stage67BytecodeOutputTermPlan::StageValue { symbol: "stage6.bytecode_read_raf.output.term.Stage5", stage_index: 4, gamma_power: 4, identity_gamma_power: None }, + Stage67BytecodeOutputTermPlan::Entry { symbol: "stage6.bytecode_read_raf.output.term.Entry", gamma_power: 7 }, ]; const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { @@ -654,7 +654,7 @@ const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafP }, entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; -pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.contribution"]; +pub const STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS: &[&str] = &["stage6.bytecode_read_raf.output.term.Stage1", "stage6.bytecode_read_raf.output.term.Stage2", "stage6.bytecode_read_raf.output.term.Stage3", "stage6.bytecode_read_raf.output.term.Stage4", "stage6.bytecode_read_raf.output.term.Stage5", "stage6.bytecode_read_raf.output.term.Entry"]; pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6Booleanity, local_scalars: &[], expected_output: "stage6.booleanity.output.claim_expr" }, Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6HammingBooleanity, local_scalars: &[], expected_output: "stage6.hamming_booleanity.output.claim_expr" }, From efbb116e852e00cbd5f54cdf21c9f405c5487848 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 01:35:52 -0600 Subject: [PATCH 121/171] refactor(verifier): check polynomial arity --- crates/bolt-verifier-runtime/src/lib.rs | 84 ++++++++++++++++++++++++- crates/jolt-poly/src/eq.rs | 23 +++++++ crates/jolt-poly/src/eq_plus_one.rs | 21 +++++++ 3 files changed, 126 insertions(+), 2 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 042c0567a3..8d9693bceb 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -1418,12 +1418,31 @@ fn evaluate_structured_polynomial( y: Vec, ) -> Result { Ok(match polynomial { - StructuredPolynomialKind::Eq => EqPolynomial::::mle(x, &y), - StructuredPolynomialKind::EqPlusOne => EqPlusOnePolynomial::::new(y).evaluate(x), + StructuredPolynomialKind::Eq => evaluate_eq_polynomial_mle(x, &y)?, + StructuredPolynomialKind::EqPlusOne => evaluate_eq_plus_one_polynomial_mle(x, y)?, StructuredPolynomialKind::Lt => evaluate_lt_polynomial_mle(x, &y)?, }) } +fn evaluate_eq_polynomial_mle(x: &[Fr], y: &[Fr]) -> Result { + EqPolynomial::::try_mle(x, y).ok_or(RuntimePlanError::InvalidInputLength { + input: "sumcheck_output.eq", + expected: x.len(), + actual: y.len(), + }) +} + +fn evaluate_eq_plus_one_polynomial_mle(x: &[Fr], y: Vec) -> Result { + let y_len = y.len(); + EqPlusOnePolynomial::::new(y) + .try_evaluate(x) + .ok_or(RuntimePlanError::InvalidInputLength { + input: "sumcheck_output.eq_plus_one", + expected: x.len(), + actual: y_len, + }) +} + fn evaluate_lt_polynomial_mle(x: &[Fr], y: &[Fr]) -> Result { LtPolynomial::try_evaluate(x, y).ok_or(RuntimePlanError::InvalidInputLength { input: "sumcheck_output.lt", @@ -2064,4 +2083,65 @@ mod tests { assert_eq!(value, Fr::from_u64(1)); } + + #[test] + fn relation_output_rejects_structured_polynomial_dimension_mismatch() { + let x = [Fr::from_u64(1)]; + let y = [Fr::from_u64(1), Fr::from_u64(0)]; + let mut store = ValueStore::default(); + store.insert_point("point.y", y.to_vec()); + + let error = evaluate_relation_output_for_instance( + &[RelationOutputPlan { + relation: TestRelation::Output, + local_scalars: &[], + expected_output: "eq.xy", + }], + &[], + &[ScalarExprPlan { + symbol: "eq.xy", + kind: ScalarExprKind::StructuredPolynomial { + polynomial: StructuredPolynomialKind::Eq, + x_point: StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + y_point: StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + }, + operands: &["instance", "point.y"], + }], + &store, + &SumcheckInstanceResultPlan { + symbol: "instance", + source: "driver", + claim: "claim", + relation: TestRelation::Output, + index: 0, + point_arity: 1, + num_rounds: 1, + round_offset: 0, + point_order: SumcheckPointOrder::AsIs, + degree: 2, + }, + &[], + &[], + &[], + &x, + ) + .unwrap_err(); + + assert_eq!( + error, + RuntimePlanError::InvalidInputLength { + input: "sumcheck_output.eq", + expected: 1, + actual: 2 + } + ); + } } diff --git a/crates/jolt-poly/src/eq.rs b/crates/jolt-poly/src/eq.rs index 8ee4601da6..939bf32a61 100644 --- a/crates/jolt-poly/src/eq.rs +++ b/crates/jolt-poly/src/eq.rs @@ -139,6 +139,20 @@ impl EqPolynomial { .fold(F::one(), |acc, v| acc * v) } + /// Checked version of [`Self::mle`]. + /// + /// Returns `None` when the two points do not have the same arity. + pub fn try_mle(x: &[C], y: &[C]) -> Option + where + C: Copy + Send + Sync + Into, + F: Mul + SubAssign, + { + if x.len() != y.len() { + return None; + } + Some(Self::mle(x, y)) + } + /// Evaluates `eq(point, index_bits)` where `index_bits` is the big-endian /// Boolean vector encoded by `index`. /// @@ -628,6 +642,15 @@ mod tests { assert_eq!(via_instance, via_static); } + #[test] + fn try_mle_rejects_dimension_mismatch() { + let x = [Fr::one(), Fr::zero()]; + let y = [Fr::one()]; + + assert_eq!(EqPolynomial::::try_mle(&x, &x), Some(Fr::one())); + assert_eq!(EqPolynomial::::try_mle(&x, &y), None); + } + #[test] fn zero_selector() { let mut rng = ChaCha20Rng::seed_from_u64(405); diff --git a/crates/jolt-poly/src/eq_plus_one.rs b/crates/jolt-poly/src/eq_plus_one.rs index 371486d1fc..2605196733 100644 --- a/crates/jolt-poly/src/eq_plus_one.rs +++ b/crates/jolt-poly/src/eq_plus_one.rs @@ -56,6 +56,16 @@ impl EqPlusOnePolynomial { .sum() } + /// Checked version of [`Self::evaluate`]. + /// + /// Returns `None` when `y` does not have the same arity as the fixed point. + pub fn try_evaluate(&self, y: &[F]) -> Option { + if y.len() != self.point.len() { + return None; + } + Some(self.evaluate(y)) + } + /// Computes full evaluation tables `(eq_evals, eq_plus_one_evals)` over the /// Boolean hypercube, where: /// @@ -217,6 +227,17 @@ mod tests { assert!(eq_plus_one.evaluate(&y).is_zero()); } + #[test] + fn try_evaluate_rejects_dimension_mismatch() { + let eq_plus_one = EqPlusOnePolynomial::new(vec![Fr::zero(), Fr::one()]); + + assert_eq!(eq_plus_one.try_evaluate(&[Fr::one()]), None); + assert_eq!( + eq_plus_one.try_evaluate(&[Fr::one(), Fr::zero()]), + Some(eq_plus_one.evaluate(&[Fr::one(), Fr::zero()])) + ); + } + #[test] fn evals_table_matches_pointwise() { let mut rng = ChaCha20Rng::seed_from_u64(42); From 574d393556e5645118b4603b32e7b6746aa37b37 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 01:48:35 -0600 Subject: [PATCH 122/171] refactor(bolt): share structured polynomial planning --- .../src/protocols/jolt/emit/rust/stage3.rs | 49 +++-------- .../src/protocols/jolt/emit/rust/stage4.rs | 49 +++-------- .../src/protocols/jolt/emit/rust/stage5.rs | 52 +++--------- .../src/protocols/jolt/emit/rust/stage6.rs | 51 ++---------- .../src/protocols/jolt/emit/rust/stage7.rs | 49 ++--------- .../jolt/verifier_relation_outputs.rs | 81 ++++++++++++++++++- 6 files changed, 126 insertions(+), 205 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 4cc3ab5745..3a2c953d83 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -6,13 +6,12 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::structured_polynomial_scalar_formula; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, FieldExprDependencies, RelationOutputAst as Stage3RelationOutputAst, + RelationOutputFieldExprPlan as Stage3RelationOutputFieldExprPlan, RelationOutputPlan as Stage3RelationOutputPlan, StructuredPolynomialEvalPlan as Stage3StructuredPolynomialEvalPlan, - StructuredPolynomialPointPlan as Stage3StructuredPolynomialPointPlan, }; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -119,24 +118,13 @@ impl FieldExprDependencies for Stage3FieldExprPlan { } } -fn stage3_structured_polynomial_scalar_expr( - value: &Stage3StructuredPolynomialEvalPlan, -) -> Stage3ScalarExprPlan { - let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; +fn stage3_scalar_expr(expr: Stage3RelationOutputFieldExprPlan) -> Stage3ScalarExprPlan { Stage3ScalarExprPlan { - symbol: value.symbol.clone(), + symbol: expr.symbol, kind: "op".to_owned(), - formula: structured_polynomial_scalar_formula( - value.polynomial.as_str(), - value.x_point.segment.as_str(), - value.x_point.length.as_str(), - value.x_point.order.as_str(), - value.y_point.segment.as_str(), - value.y_point.length.as_str(), - value.y_point.order.as_str(), - ), - operand_names: operands.clone(), - operands, + formula: expr.formula, + operand_names: expr.operands.clone(), + operands: expr.operands, } } @@ -522,25 +510,9 @@ impl Stage3CpuProgram { }); } "cpu.structured_polynomial_eval" => { - let symbol = string_attr(op, "sym_name")?; - let x_point = Stage3StructuredPolynomialPointPlan::from_cpu( - operand_symbol(op, 0)?, - string_attr(op, "x_point_segment")?, - string_attr(op, "x_point_length")?, - string_attr(op, "x_point_order")?, - )?; - let y_point = Stage3StructuredPolynomialPointPlan::from_cpu( - operand_symbol(op, 1)?, - string_attr(op, "y_point_segment")?, - string_attr(op, "y_point_length")?, - string_attr(op, "y_point_order")?, - )?; - relation_output_values.push(Stage3StructuredPolynomialEvalPlan::from_cpu( - symbol, - string_attr(op, "polynomial")?, - x_point, - y_point, - )?); + relation_output_values.push( + verifier_relation_outputs::parse_structured_polynomial_eval_plan(op)?, + ); } "cpu.sumcheck_output_claim" => { relation_output_asts.push(Stage3RelationOutputAst { @@ -609,7 +581,8 @@ impl Stage3CpuProgram { scalar_exprs.extend( relation_output_values .iter() - .map(stage3_structured_polynomial_scalar_expr), + .map(verifier_relation_outputs::structured_polynomial_scalar_expr_plan) + .map(stage3_scalar_expr), ); } if role == Role::Prover { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index cc80dbb18a..a31575e7ee 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -11,13 +11,12 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::structured_polynomial_scalar_formula; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, FieldExprDependencies, RelationOutputAst as Stage4RelationOutputAst, + RelationOutputFieldExprPlan as Stage4RelationOutputFieldExprPlan, RelationOutputPlan as Stage4RelationOutputPlan, StructuredPolynomialEvalPlan as Stage4StructuredPolynomialEvalPlan, - StructuredPolynomialPointPlan as Stage4StructuredPolynomialPointPlan, }; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -132,24 +131,13 @@ impl FieldExprDependencies for Stage4FieldExprPlan { } } -fn stage4_structured_polynomial_scalar_expr( - value: &Stage4StructuredPolynomialEvalPlan, -) -> Stage4ScalarExprPlan { - let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; +fn stage4_scalar_expr(expr: Stage4RelationOutputFieldExprPlan) -> Stage4ScalarExprPlan { Stage4ScalarExprPlan { - symbol: value.symbol.clone(), + symbol: expr.symbol, kind: "op".to_owned(), - formula: structured_polynomial_scalar_formula( - value.polynomial.as_str(), - value.x_point.segment.as_str(), - value.x_point.length.as_str(), - value.x_point.order.as_str(), - value.y_point.segment.as_str(), - value.y_point.length.as_str(), - value.y_point.order.as_str(), - ), - operand_names: operands.clone(), - operands, + formula: expr.formula, + operand_names: expr.operands.clone(), + operands: expr.operands, } } @@ -534,25 +522,9 @@ impl Stage4CpuProgram { }); } "cpu.structured_polynomial_eval" => { - let symbol = string_attr(op, "sym_name")?; - let x_point = Stage4StructuredPolynomialPointPlan::from_cpu( - operand_symbol(op, 0)?, - string_attr(op, "x_point_segment")?, - string_attr(op, "x_point_length")?, - string_attr(op, "x_point_order")?, - )?; - let y_point = Stage4StructuredPolynomialPointPlan::from_cpu( - operand_symbol(op, 1)?, - string_attr(op, "y_point_segment")?, - string_attr(op, "y_point_length")?, - string_attr(op, "y_point_order")?, - )?; - relation_output_values.push(Stage4StructuredPolynomialEvalPlan::from_cpu( - symbol, - string_attr(op, "polynomial")?, - x_point, - y_point, - )?); + relation_output_values.push( + verifier_relation_outputs::parse_structured_polynomial_eval_plan(op)?, + ); } "cpu.sumcheck_output_claim" => { relation_output_asts.push(Stage4RelationOutputAst { @@ -621,7 +593,8 @@ impl Stage4CpuProgram { scalar_exprs.extend( relation_output_values .iter() - .map(stage4_structured_polynomial_scalar_expr), + .map(verifier_relation_outputs::structured_polynomial_scalar_expr_plan) + .map(stage4_scalar_expr), ); } if role == Role::Prover { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index ddae97a86e..1a2fb063aa 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -11,9 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::{ - structured_polynomial_scalar_formula, FieldExprKind, ScalarExprKind, -}; +use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, }; @@ -24,11 +22,11 @@ use crate::protocols::jolt::verifier_relation_outputs::{ parse_output_product_family_plan, FieldExprDependencies, RelationOutputAst as Stage5RelationOutputAst, RelationOutputEvalFamilyPlan as Stage5RelationOutputEvalFamilyPlan, + RelationOutputFieldExprPlan as Stage5RelationOutputFieldExprPlan, RelationOutputFunctionFamilyPlan as Stage5RelationOutputFunctionFamilyPlan, RelationOutputPlan as Stage5RelationOutputPlan, RelationOutputProductFamilyPlan as Stage5RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, - StructuredPolynomialPointPlan as Stage5StructuredPolynomialPointPlan, }; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -234,24 +232,15 @@ fn stage5_scalar_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stag } } -fn stage5_structured_polynomial_scalar_expr( - value: &Stage5StructuredPolynomialEvalPlan, +fn stage5_relation_output_scalar_expr( + expr: Stage5RelationOutputFieldExprPlan, ) -> Stage5ScalarExprPlan { - let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; Stage5ScalarExprPlan { - symbol: value.symbol.clone(), + symbol: expr.symbol, kind: "op".to_owned(), - formula: structured_polynomial_scalar_formula( - value.polynomial.as_str(), - value.x_point.segment.as_str(), - value.x_point.length.as_str(), - value.x_point.order.as_str(), - value.y_point.segment.as_str(), - value.y_point.length.as_str(), - value.y_point.order.as_str(), - ), - operand_names: operands.clone(), - operands, + formula: expr.formula, + operand_names: expr.operands.clone(), + operands: expr.operands, } } @@ -581,25 +570,9 @@ impl Stage5CpuProgram { .push(verifier_eval_families::parse_indexed_eval_family(op)?); } "cpu.structured_polynomial_eval" => { - let symbol = string_attr(op, "sym_name")?; - let x_point = Stage5StructuredPolynomialPointPlan::from_cpu( - operand_symbol(op, 0)?, - string_attr(op, "x_point_segment")?, - string_attr(op, "x_point_length")?, - string_attr(op, "x_point_order")?, - )?; - let y_point = Stage5StructuredPolynomialPointPlan::from_cpu( - operand_symbol(op, 1)?, - string_attr(op, "y_point_segment")?, - string_attr(op, "y_point_length")?, - string_attr(op, "y_point_order")?, - )?; - relation_output_values.push(Stage5StructuredPolynomialEvalPlan::from_cpu( - symbol, - string_attr(op, "polynomial")?, - x_point, - y_point, - )?); + relation_output_values.push( + verifier_relation_outputs::parse_structured_polynomial_eval_plan(op)?, + ); } "cpu.sumcheck_output_eval_family" => { relation_output_eval_families @@ -716,7 +689,8 @@ impl Stage5CpuProgram { scalar_exprs.extend( relation_output_values .iter() - .map(stage5_structured_polynomial_scalar_expr), + .map(verifier_relation_outputs::structured_polynomial_scalar_expr_plan) + .map(stage5_relation_output_scalar_expr), ); } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 2f927f749b..bb74fe89f2 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -11,9 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; -use crate::protocols::jolt::rust_target_plan::{ - structured_polynomial_scalar_formula, FieldExprKind, ScalarExprKind, -}; +use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, stage6_bytecode_read_raf_relation_output_plan, STAGE6_BYTECODE_RA_EVAL_FAMILY, @@ -30,7 +28,6 @@ use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputPlan as Stage6RelationOutputPlan, RelationOutputProductFamilyPlan as Stage6RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan, - StructuredPolynomialPointPlan as Stage6StructuredPolynomialPointPlan, }; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -579,25 +576,9 @@ impl Stage6CpuProgram { .push(verifier_eval_families::parse_indexed_eval_family(op)?); } "cpu.structured_polynomial_eval" => { - let symbol = string_attr(op, "sym_name")?; - let x_point = Stage6StructuredPolynomialPointPlan::from_cpu( - operand_symbol(op, 0)?, - string_attr(op, "x_point_segment")?, - string_attr(op, "x_point_length")?, - string_attr(op, "x_point_order")?, - )?; - let y_point = Stage6StructuredPolynomialPointPlan::from_cpu( - operand_symbol(op, 1)?, - string_attr(op, "y_point_segment")?, - string_attr(op, "y_point_length")?, - string_attr(op, "y_point_order")?, - )?; - relation_output_values.push(Stage6StructuredPolynomialEvalPlan::from_cpu( - symbol, - string_attr(op, "polynomial")?, - x_point, - y_point, - )?); + relation_output_values.push( + verifier_relation_outputs::parse_structured_polynomial_eval_plan(op)?, + ); } "cpu.sumcheck_output_eval_family" => { relation_output_eval_families @@ -730,7 +711,8 @@ impl Stage6CpuProgram { scalar_exprs.extend( relation_output_values .iter() - .map(stage6_structured_polynomial_scalar_expr), + .map(verifier_relation_outputs::structured_polynomial_scalar_expr_plan) + .map(stage6_scalar_expr), ); } @@ -2868,27 +2850,6 @@ fn stage6_scalar_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage6ScalarEx } } -fn stage6_structured_polynomial_scalar_expr( - value: &Stage6StructuredPolynomialEvalPlan, -) -> Stage6ScalarExprPlan { - let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; - Stage6ScalarExprPlan { - symbol: value.symbol.clone(), - kind: "op".to_owned(), - formula: structured_polynomial_scalar_formula( - value.polynomial.as_str(), - value.x_point.segment.as_str(), - value.x_point.length.as_str(), - value.x_point.order.as_str(), - value.y_point.segment.as_str(), - value.y_point.length.as_str(), - value.y_point.order.as_str(), - ), - operand_names: operands.clone(), - operands, - } -} - fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { STAGE6_KERNEL_ABIS .iter() diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 1dbcd8cb31..4b43664c9c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -12,7 +12,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::rust_target_plan::{ - power_strided_weighted_sum_formula, structured_polynomial_scalar_formula, ScalarExprKind, + power_strided_weighted_sum_formula, ScalarExprKind, }; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ @@ -25,7 +25,6 @@ use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputPlan as Stage7RelationOutputPlan, RelationOutputProductFamilyPlan as Stage7RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan, - StructuredPolynomialPointPlan as Stage7StructuredPolynomialPointPlan, }; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -177,27 +176,6 @@ fn stage7_scalar_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage7ScalarEx } } -fn stage7_structured_polynomial_scalar_expr( - value: &Stage7StructuredPolynomialEvalPlan, -) -> Stage7ScalarExprPlan { - let operands = vec![value.x_point.source.clone(), value.y_point.source.clone()]; - Stage7ScalarExprPlan { - symbol: value.symbol.clone(), - kind: "op".to_owned(), - formula: structured_polynomial_scalar_formula( - value.polynomial.as_str(), - value.x_point.segment.as_str(), - value.x_point.length.as_str(), - value.x_point.order.as_str(), - value.y_point.segment.as_str(), - value.y_point.length.as_str(), - value.y_point.order.as_str(), - ), - operand_names: operands.clone(), - operands, - } -} - struct HammingWeightClaimRow { hamming_factor: String, booleanity: String, @@ -722,25 +700,9 @@ impl Stage7CpuProgram { }); } "cpu.structured_polynomial_eval" => { - let symbol = string_attr(op, "sym_name")?; - let x_point = Stage7StructuredPolynomialPointPlan::from_cpu( - operand_symbol(op, 0)?, - string_attr(op, "x_point_segment")?, - string_attr(op, "x_point_length")?, - string_attr(op, "x_point_order")?, - )?; - let y_point = Stage7StructuredPolynomialPointPlan::from_cpu( - operand_symbol(op, 1)?, - string_attr(op, "y_point_segment")?, - string_attr(op, "y_point_length")?, - string_attr(op, "y_point_order")?, - )?; - relation_output_values.push(Stage7StructuredPolynomialEvalPlan::from_cpu( - symbol, - string_attr(op, "polynomial")?, - x_point, - y_point, - )?); + relation_output_values.push( + verifier_relation_outputs::parse_structured_polynomial_eval_plan(op)?, + ); } "cpu.sumcheck_output_eval_family" => { relation_output_eval_families @@ -870,7 +832,8 @@ impl Stage7CpuProgram { scalar_exprs.extend( relation_output_values .iter() - .map(stage7_structured_polynomial_scalar_expr), + .map(verifier_relation_outputs::structured_polynomial_scalar_expr_plan) + .map(stage7_scalar_expr), ); } diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 960a392e38..1c15e6adbc 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -8,7 +8,9 @@ use crate::protocols::jolt::cpu_attrs::{ int_array_attr, int_attr, operation_name, optional_symbol_array_attr, string_array_attr, string_attr, symbol_array_attr, }; -use crate::protocols::jolt::rust_target_plan::power_strided_weighted_sum_formula; +use crate::protocols::jolt::rust_target_plan::{ + power_strided_weighted_sum_formula, structured_polynomial_scalar_formula, +}; use crate::protocols::jolt::verifier_values::{VerifierPointSourceSet, VerifierScalarSourceSet}; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -196,6 +198,47 @@ impl StructuredPolynomialEvalPlan { } } +pub fn parse_structured_polynomial_eval_plan( + operation: OperationRef<'_, '_>, +) -> Result { + let x_point = StructuredPolynomialPointPlan::from_cpu( + operand_symbol(operation, 0)?, + string_attr(operation, "x_point_segment")?, + string_attr(operation, "x_point_length")?, + string_attr(operation, "x_point_order")?, + )?; + let y_point = StructuredPolynomialPointPlan::from_cpu( + operand_symbol(operation, 1)?, + string_attr(operation, "y_point_segment")?, + string_attr(operation, "y_point_length")?, + string_attr(operation, "y_point_order")?, + )?; + StructuredPolynomialEvalPlan::from_cpu( + string_attr(operation, "sym_name")?, + string_attr(operation, "polynomial")?, + x_point, + y_point, + ) +} + +pub fn structured_polynomial_scalar_expr_plan( + value: &StructuredPolynomialEvalPlan, +) -> RelationOutputFieldExprPlan { + RelationOutputFieldExprPlan { + symbol: value.symbol.clone(), + formula: structured_polynomial_scalar_formula( + value.polynomial.as_str(), + value.x_point.segment.as_str(), + value.x_point.length.as_str(), + value.x_point.order.as_str(), + value.y_point.segment.as_str(), + value.y_point.length.as_str(), + value.y_point.order.as_str(), + ), + operands: vec![value.x_point.source.clone(), value.y_point.source.clone()], + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputEvalFamilySharedTermPlan { pub gamma_power_offset: usize, @@ -1481,7 +1524,9 @@ mod tests { RelationOutputEvalFamilySharedTermPlan, RelationOutputFunctionFamilyPlan, RelationOutputFunctionFamilyTermPlan, RelationOutputFunctionKind, RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, - RelationOutputVerification, + RelationOutputVerification, StructuredPolynomialEvalPlan, StructuredPolynomialKind, + StructuredPolynomialPointLength, StructuredPolynomialPointOrder, + StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, }; struct TestFieldExpr { @@ -1499,6 +1544,38 @@ mod tests { } } + #[test] + fn structured_polynomial_scalar_expr_plan_preserves_typed_point_transforms() { + let value = StructuredPolynomialEvalPlan { + symbol: "eq.output".to_owned(), + polynomial: StructuredPolynomialKind::EqPlusOne, + x_point: StructuredPolynomialPointPlan { + source: "x.source".to_owned(), + segment: StructuredPolynomialPointSegment::Prefix, + length: StructuredPolynomialPointLength::YPoint, + order: StructuredPolynomialPointOrder::Reverse, + }, + y_point: StructuredPolynomialPointPlan { + source: "y.source".to_owned(), + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + }; + + let expr = super::structured_polynomial_scalar_expr_plan(&value); + + assert_eq!(expr.symbol, "eq.output"); + assert_eq!( + expr.formula, + "poly.structured_eval:eq_plus_one:prefix:y_point:reverse:full:full:as_is" + ); + assert_eq!( + expr.operands, + vec!["x.source".to_owned(), "y.source".to_owned()] + ); + } + #[test] fn resolve_rejects_unlowered_eval_families_reachable_through_field_expressions( ) -> Result<(), EmitError> { From e5749d35040637b81229557643f3f251c73730f3 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 01:59:52 -0600 Subject: [PATCH 123/171] refactor(bolt): share opening row plans Use common CPU-side opening claim, equality, and batch row types across Stage 3-7 emitter programs. This removes the per-stage opening-row associated types from the verifier-stage source trait while leaving generated verifier runtime templates unchanged. --- .../src/protocols/jolt/emit/rust/stage3.rs | 45 +---- .../src/protocols/jolt/emit/rust/stage4.rs | 45 +---- .../src/protocols/jolt/emit/rust/stage5.rs | 45 +---- .../src/protocols/jolt/emit/rust/stage6.rs | 45 +---- .../src/protocols/jolt/emit/rust/stage7.rs | 45 +---- .../bolt/src/protocols/jolt/verifier_plan.rs | 157 +++++++++++++----- 6 files changed, 145 insertions(+), 237 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 3a2c953d83..6354ca0ad1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -37,9 +37,9 @@ pub struct Stage3CpuProgram { pub relation_outputs: Vec, pub point_slices: Vec, pub point_concats: Vec, - pub opening_claims: Vec, - pub opening_equalities: Vec, - pub opening_batches: Vec, + pub opening_claims: Vec, + pub opening_equalities: Vec, + pub opening_batches: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -212,36 +212,6 @@ pub struct Stage3PointConcatPlan { pub inputs: Vec, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3OpeningClaimPlan { - pub symbol: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, - pub point_source: String, - pub eval_source: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3OpeningClaimEqualityPlan { - pub symbol: String, - pub mode: String, - pub lhs: String, - pub rhs: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3OpeningBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage3CpuProgram, step = Stage3ProgramStepPlan, @@ -257,9 +227,6 @@ verifier_plan::impl_verifier_plan_source_traits!( eval = Stage3SumcheckEvalPlan, point_slice = Stage3PointSlicePlan, point_concat = Stage3PointConcatPlan, - opening_claim = Stage3OpeningClaimPlan, - opening_equality = Stage3OpeningClaimEqualityPlan, - opening_batch = Stage3OpeningBatchPlan, ); pub fn stage3_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -540,7 +507,7 @@ impl Stage3CpuProgram { }); } "cpu.opening_claim" => { - opening_claims.push(Stage3OpeningClaimPlan { + opening_claims.push(verifier_plan::CpuOpeningClaimPlan { symbol: string_attr(op, "sym_name")?, oracle: symbol_attr(op, "oracle")?, domain: symbol_attr(op, "domain")?, @@ -551,7 +518,7 @@ impl Stage3CpuProgram { }); } "cpu.opening_claim_equal" => { - opening_equalities.push(Stage3OpeningClaimEqualityPlan { + opening_equalities.push(verifier_plan::CpuOpeningClaimEqualityPlan { symbol: string_attr(op, "sym_name")?, mode: string_attr(op, "mode")?, lhs: operand_symbol(op, 0)?, @@ -559,7 +526,7 @@ impl Stage3CpuProgram { }); } "cpu.opening_batch" => { - opening_batches.push(Stage3OpeningBatchPlan { + opening_batches.push(verifier_plan::CpuOpeningBatchPlan { symbol: string_attr(op, "sym_name")?, stage: symbol_attr(op, "stage")?, proof_slot: symbol_attr(op, "proof_slot")?, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index a31575e7ee..ea32861ea3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -43,9 +43,9 @@ pub struct Stage4CpuProgram { pub relation_outputs: Vec, pub point_slices: Vec, pub point_concats: Vec, - pub opening_claims: Vec, - pub opening_equalities: Vec, - pub opening_batches: Vec, + pub opening_claims: Vec, + pub opening_equalities: Vec, + pub opening_batches: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -225,36 +225,6 @@ pub struct Stage4PointConcatPlan { pub inputs: Vec, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4OpeningClaimPlan { - pub symbol: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, - pub point_source: String, - pub eval_source: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4OpeningClaimEqualityPlan { - pub symbol: String, - pub mode: String, - pub lhs: String, - pub rhs: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4OpeningBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage4CpuProgram, step = Stage4ProgramStepPlan, @@ -270,9 +240,6 @@ verifier_plan::impl_verifier_plan_source_traits!( eval = Stage4SumcheckEvalPlan, point_slice = Stage4PointSlicePlan, point_concat = Stage4PointConcatPlan, - opening_claim = Stage4OpeningClaimPlan, - opening_equality = Stage4OpeningClaimEqualityPlan, - opening_batch = Stage4OpeningBatchPlan, absorb = Stage4TranscriptAbsorbBytesPlan, ); @@ -552,7 +519,7 @@ impl Stage4CpuProgram { }); } "cpu.opening_claim" => { - opening_claims.push(Stage4OpeningClaimPlan { + opening_claims.push(verifier_plan::CpuOpeningClaimPlan { symbol: string_attr(op, "sym_name")?, oracle: symbol_attr(op, "oracle")?, domain: symbol_attr(op, "domain")?, @@ -563,7 +530,7 @@ impl Stage4CpuProgram { }); } "cpu.opening_claim_equal" => { - opening_equalities.push(Stage4OpeningClaimEqualityPlan { + opening_equalities.push(verifier_plan::CpuOpeningClaimEqualityPlan { symbol: string_attr(op, "sym_name")?, mode: string_attr(op, "mode")?, lhs: operand_symbol(op, 0)?, @@ -571,7 +538,7 @@ impl Stage4CpuProgram { }); } "cpu.opening_batch" => { - opening_batches.push(Stage4OpeningBatchPlan { + opening_batches.push(verifier_plan::CpuOpeningBatchPlan { symbol: string_attr(op, "sym_name")?, stage: symbol_attr(op, "stage")?, proof_slot: symbol_attr(op, "proof_slot")?, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 1a2fb063aa..e5be2b9bc8 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -57,9 +57,9 @@ pub struct Stage5CpuProgram { pub relation_outputs: Vec, pub point_slices: Vec, pub point_concats: Vec, - pub opening_claims: Vec, - pub opening_equalities: Vec, - pub opening_batches: Vec, + pub opening_claims: Vec, + pub opening_equalities: Vec, + pub opening_batches: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -261,36 +261,6 @@ pub struct Stage5PointConcatPlan { pub inputs: Vec, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5OpeningClaimPlan { - pub symbol: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, - pub point_source: String, - pub eval_source: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5OpeningClaimEqualityPlan { - pub symbol: String, - pub mode: String, - pub lhs: String, - pub rhs: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5OpeningBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage5CpuProgram, step = Stage5ProgramStepPlan, @@ -306,9 +276,6 @@ verifier_plan::impl_verifier_plan_source_traits!( eval = Stage5SumcheckEvalPlan, point_slice = Stage5PointSlicePlan, point_concat = Stage5PointConcatPlan, - opening_claim = Stage5OpeningClaimPlan, - opening_equality = Stage5OpeningClaimEqualityPlan, - opening_batch = Stage5OpeningBatchPlan, absorb = Stage5TranscriptAbsorbBytesPlan, indexed_eval_families = indexed_eval_families, relation_output_eval_families = relation_output_eval_families, @@ -612,7 +579,7 @@ impl Stage5CpuProgram { }); } "cpu.opening_claim" => { - opening_claims.push(Stage5OpeningClaimPlan { + opening_claims.push(verifier_plan::CpuOpeningClaimPlan { symbol: string_attr(op, "sym_name")?, oracle: symbol_attr(op, "oracle")?, domain: symbol_attr(op, "domain")?, @@ -623,7 +590,7 @@ impl Stage5CpuProgram { }); } "cpu.opening_claim_equal" => { - opening_equalities.push(Stage5OpeningClaimEqualityPlan { + opening_equalities.push(verifier_plan::CpuOpeningClaimEqualityPlan { symbol: string_attr(op, "sym_name")?, mode: string_attr(op, "mode")?, lhs: operand_symbol(op, 0)?, @@ -631,7 +598,7 @@ impl Stage5CpuProgram { }); } "cpu.opening_batch" => { - opening_batches.push(Stage5OpeningBatchPlan { + opening_batches.push(verifier_plan::CpuOpeningBatchPlan { symbol: string_attr(op, "sym_name")?, stage: symbol_attr(op, "stage")?, proof_slot: symbol_attr(op, "proof_slot")?, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index bb74fe89f2..152b6089da 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -86,9 +86,9 @@ pub struct Stage6CpuProgram { pub point_zeros: Vec, pub point_slices: Vec, pub point_concats: Vec, - pub opening_claims: Vec, - pub opening_equalities: Vec, - pub opening_batches: Vec, + pub opening_claims: Vec, + pub opening_equalities: Vec, + pub opening_batches: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -265,36 +265,6 @@ pub struct Stage6PointConcatPlan { pub inputs: Vec, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6OpeningClaimPlan { - pub symbol: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, - pub point_source: String, - pub eval_source: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6OpeningClaimEqualityPlan { - pub symbol: String, - pub mode: String, - pub lhs: String, - pub rhs: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6OpeningBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage6CpuProgram, step = Stage6ProgramStepPlan, @@ -310,9 +280,6 @@ verifier_plan::impl_verifier_plan_source_traits!( eval = Stage6SumcheckEvalPlan, point_slice = Stage6PointSlicePlan, point_concat = Stage6PointConcatPlan, - opening_claim = Stage6OpeningClaimPlan, - opening_equality = Stage6OpeningClaimEqualityPlan, - opening_batch = Stage6OpeningBatchPlan, absorb = Stage6TranscriptAbsorbBytesPlan, point_zero = Stage6PointZeroPlan, indexed_eval_families = indexed_eval_families, @@ -625,7 +592,7 @@ impl Stage6CpuProgram { }); } "cpu.opening_claim" => { - opening_claims.push(Stage6OpeningClaimPlan { + opening_claims.push(verifier_plan::CpuOpeningClaimPlan { symbol: string_attr(op, "sym_name")?, oracle: symbol_attr(op, "oracle")?, domain: symbol_attr(op, "domain")?, @@ -636,7 +603,7 @@ impl Stage6CpuProgram { }); } "cpu.opening_claim_equal" => { - opening_equalities.push(Stage6OpeningClaimEqualityPlan { + opening_equalities.push(verifier_plan::CpuOpeningClaimEqualityPlan { symbol: string_attr(op, "sym_name")?, mode: string_attr(op, "mode")?, lhs: operand_symbol(op, 0)?, @@ -644,7 +611,7 @@ impl Stage6CpuProgram { }); } "cpu.opening_batch" => { - opening_batches.push(Stage6OpeningBatchPlan { + opening_batches.push(verifier_plan::CpuOpeningBatchPlan { symbol: string_attr(op, "sym_name")?, stage: symbol_attr(op, "stage")?, proof_slot: symbol_attr(op, "proof_slot")?, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 4b43664c9c..92c95cbb01 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -68,9 +68,9 @@ pub struct Stage7CpuProgram { pub point_zeros: Vec, pub point_slices: Vec, pub point_concats: Vec, - pub opening_claims: Vec, - pub opening_equalities: Vec, - pub opening_batches: Vec, + pub opening_claims: Vec, + pub opening_equalities: Vec, + pub opening_batches: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -395,36 +395,6 @@ pub struct Stage7PointConcatPlan { pub inputs: Vec, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7OpeningClaimPlan { - pub symbol: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, - pub point_source: String, - pub eval_source: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7OpeningClaimEqualityPlan { - pub symbol: String, - pub mode: String, - pub lhs: String, - pub rhs: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7OpeningBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage7CpuProgram, step = Stage7ProgramStepPlan, @@ -440,9 +410,6 @@ verifier_plan::impl_verifier_plan_source_traits!( eval = Stage7SumcheckEvalPlan, point_slice = Stage7PointSlicePlan, point_concat = Stage7PointConcatPlan, - opening_claim = Stage7OpeningClaimPlan, - opening_equality = Stage7OpeningClaimEqualityPlan, - opening_batch = Stage7OpeningBatchPlan, absorb = Stage7TranscriptAbsorbBytesPlan, point_zero = Stage7PointZeroPlan, relation_output_eval_families = relation_output_eval_families, @@ -749,7 +716,7 @@ impl Stage7CpuProgram { }); } "cpu.opening_claim" => { - opening_claims.push(Stage7OpeningClaimPlan { + opening_claims.push(verifier_plan::CpuOpeningClaimPlan { symbol: string_attr(op, "sym_name")?, oracle: symbol_attr(op, "oracle")?, domain: symbol_attr(op, "domain")?, @@ -760,7 +727,7 @@ impl Stage7CpuProgram { }); } "cpu.opening_claim_equal" => { - opening_equalities.push(Stage7OpeningClaimEqualityPlan { + opening_equalities.push(verifier_plan::CpuOpeningClaimEqualityPlan { symbol: string_attr(op, "sym_name")?, mode: string_attr(op, "mode")?, lhs: operand_symbol(op, 0)?, @@ -768,7 +735,7 @@ impl Stage7CpuProgram { }); } "cpu.opening_batch" => { - opening_batches.push(Stage7OpeningBatchPlan { + opening_batches.push(verifier_plan::CpuOpeningBatchPlan { symbol: string_attr(op, "sym_name")?, stage: symbol_attr(op, "stage")?, proof_slot: symbol_attr(op, "proof_slot")?, diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 86b2564d80..6d07e1e0bd 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -261,6 +261,36 @@ pub(crate) struct VerifierOpeningBatchPlan { pub(crate) claim_operands: Vec, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuOpeningClaimPlan { + pub symbol: String, + pub oracle: String, + pub domain: String, + pub point_arity: usize, + pub claim_kind: String, + pub point_source: String, + pub eval_source: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuOpeningClaimEqualityPlan { + pub symbol: String, + pub mode: String, + pub lhs: String, + pub rhs: String, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuOpeningBatchPlan { + pub symbol: String, + pub stage: String, + pub proof_slot: String, + pub policy: String, + pub count: usize, + pub ordered_claims: Vec, + pub claim_operands: Vec, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierStagePlan { pub(crate) steps: Vec, @@ -558,9 +588,6 @@ pub(crate) trait VerifierStagePlanSource { type Eval: VerifierSumcheckEvalSource; type PointSlice: VerifierPointSliceSource; type PointConcat: VerifierPointConcatSource; - type OpeningClaim: VerifierOpeningClaimSource; - type OpeningEquality: VerifierOpeningClaimEqualitySource; - type OpeningBatch: VerifierOpeningBatchSource; fn steps(&self) -> &[Self::Step]; fn transcript_squeezes(&self) -> &[Self::Squeeze]; @@ -587,9 +614,87 @@ pub(crate) trait VerifierStagePlanSource { } fn relation_outputs(&self) -> &[RelationOutputPlan]; fn point_exprs(&self) -> Vec; - fn opening_claims(&self) -> &[Self::OpeningClaim]; - fn opening_equalities(&self) -> &[Self::OpeningEquality]; - fn opening_batches(&self) -> &[Self::OpeningBatch]; + fn opening_claims(&self) -> &[CpuOpeningClaimPlan]; + fn opening_equalities(&self) -> &[CpuOpeningClaimEqualityPlan]; + fn opening_batches(&self) -> &[CpuOpeningBatchPlan]; +} + +impl VerifierOpeningClaimSource for CpuOpeningClaimPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn oracle(&self) -> &str { + &self.oracle + } + + fn domain(&self) -> &str { + &self.domain + } + + fn point_arity(&self) -> usize { + self.point_arity + } + + fn claim_kind(&self) -> &str { + &self.claim_kind + } + + fn point_source(&self) -> &str { + &self.point_source + } + + fn eval_source(&self) -> &str { + &self.eval_source + } +} + +impl VerifierOpeningClaimEqualitySource for CpuOpeningClaimEqualityPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn mode(&self) -> &str { + &self.mode + } + + fn lhs(&self) -> &str { + &self.lhs + } + + fn rhs(&self) -> &str { + &self.rhs + } +} + +impl VerifierOpeningBatchSource for CpuOpeningBatchPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn stage(&self) -> &str { + &self.stage + } + + fn proof_slot(&self) -> &str { + &self.proof_slot + } + + fn policy(&self) -> &str { + &self.policy + } + + fn count(&self) -> usize { + self.count + } + + fn ordered_claims(&self) -> &[String] { + &self.ordered_claims + } + + fn claim_operands(&self) -> &[String] { + &self.claim_operands + } } pub(crate) fn stage_plan_from_cpu_sources( @@ -895,10 +1000,7 @@ macro_rules! impl_verifier_plan_source_traits { instance = $instance:ty, eval = $eval:ty, point_slice = $point_slice:ty, - point_concat = $point_concat:ty, - opening_claim = $opening_claim:ty, - opening_equality = $opening_equality:ty, - opening_batch = $opening_batch:ty + point_concat = $point_concat:ty $(, absorb = $absorb:ty)? $(, point_zero = $point_zero:ty)? $(, indexed_eval_families = $indexed_eval_families:ident)? @@ -921,9 +1023,6 @@ macro_rules! impl_verifier_plan_source_traits { type Eval = $eval; type PointSlice = $point_slice; type PointConcat = $point_concat; - type OpeningClaim = $opening_claim; - type OpeningEquality = $opening_equality; - type OpeningBatch = $opening_batch; fn steps(&self) -> &[Self::Step] { &self.steps } fn transcript_squeezes(&self) -> &[Self::Squeeze] { &self.transcript_squeezes } @@ -972,9 +1071,9 @@ macro_rules! impl_verifier_plan_source_traits { @point_exprs self $(, $point_zero)? ) } - fn opening_claims(&self) -> &[Self::OpeningClaim] { &self.opening_claims } - fn opening_equalities(&self) -> &[Self::OpeningEquality] { &self.opening_equalities } - fn opening_batches(&self) -> &[Self::OpeningBatch] { &self.opening_batches } + fn opening_claims(&self) -> &[$crate::protocols::jolt::verifier_plan::CpuOpeningClaimPlan] { &self.opening_claims } + fn opening_equalities(&self) -> &[$crate::protocols::jolt::verifier_plan::CpuOpeningClaimEqualityPlan] { &self.opening_equalities } + fn opening_batches(&self) -> &[$crate::protocols::jolt::verifier_plan::CpuOpeningBatchPlan] { &self.opening_batches } } impl $crate::protocols::jolt::verifier_plan::VerifierProgramStepSource for $step { @@ -1105,32 +1204,6 @@ macro_rules! impl_verifier_plan_source_traits { fn inputs(&self) -> &[String] { &self.inputs } } - impl $crate::protocols::jolt::verifier_plan::VerifierOpeningClaimSource for $opening_claim { - fn symbol(&self) -> &str { &self.symbol } - fn oracle(&self) -> &str { &self.oracle } - fn domain(&self) -> &str { &self.domain } - fn point_arity(&self) -> usize { self.point_arity } - fn claim_kind(&self) -> &str { &self.claim_kind } - fn point_source(&self) -> &str { &self.point_source } - fn eval_source(&self) -> &str { &self.eval_source } - } - - impl $crate::protocols::jolt::verifier_plan::VerifierOpeningClaimEqualitySource for $opening_equality { - fn symbol(&self) -> &str { &self.symbol } - fn mode(&self) -> &str { &self.mode } - fn lhs(&self) -> &str { &self.lhs } - fn rhs(&self) -> &str { &self.rhs } - } - - impl $crate::protocols::jolt::verifier_plan::VerifierOpeningBatchSource for $opening_batch { - fn symbol(&self) -> &str { &self.symbol } - fn stage(&self) -> &str { &self.stage } - fn proof_slot(&self) -> &str { &self.proof_slot } - fn policy(&self) -> &str { &self.policy } - fn count(&self) -> usize { self.count } - fn ordered_claims(&self) -> &[String] { &self.ordered_claims } - fn claim_operands(&self) -> &[String] { &self.claim_operands } - } }; (@transcript_absorb_bytes $self:ident, $absorb:ty) => { $crate::protocols::jolt::verifier_plan::transcript_absorb_bytes_from_cpu( From a93fe29f32784e9f039bfc2af698889d6c833e0f Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 02:08:27 -0600 Subject: [PATCH 124/171] refactor(bolt): centralize opening parsing Add a shared verifier opening-row parser and cut Stage 3-7 emitters over to it. This keeps opening-row MLIR parsing out of verifier_plan while preserving the generated verifier API. --- crates/bolt/src/protocols/jolt/cpu_attrs.rs | 43 ++++++++++- .../src/protocols/jolt/emit/rust/stage3.rs | 35 ++------- .../src/protocols/jolt/emit/rust/stage4.rs | 35 ++------- .../src/protocols/jolt/emit/rust/stage5.rs | 35 ++------- .../src/protocols/jolt/emit/rust/stage6.rs | 35 ++------- .../src/protocols/jolt/emit/rust/stage7.rs | 35 ++------- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../protocols/jolt/verifier_opening_rows.rs | 75 +++++++++++++++++++ .../bolt/src/protocols/jolt/verifier_plan.rs | 39 ++-------- 9 files changed, 163 insertions(+), 170 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_opening_rows.rs diff --git a/crates/bolt/src/protocols/jolt/cpu_attrs.rs b/crates/bolt/src/protocols/jolt/cpu_attrs.rs index 1de4efd4fd..3c00a1062d 100644 --- a/crates/bolt/src/protocols/jolt/cpu_attrs.rs +++ b/crates/bolt/src/protocols/jolt/cpu_attrs.rs @@ -1,8 +1,8 @@ -use melior::ir::operation::OperationLike; +use melior::ir::operation::{OperationLike, OperationResult}; use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::EmitError; -use crate::ir::string_attribute_value; +use crate::ir::{string_attribute_value, symbol_attribute_value}; pub(crate) fn string_attr( operation: OperationRef<'_, '_>, @@ -15,6 +15,17 @@ pub(crate) fn string_attr( .ok_or_else(|| attr_error(operation, attr, "string")) } +pub(crate) fn symbol_attr( + operation: OperationRef<'_, '_>, + attr: &str, +) -> Result { + operation + .attribute(attr) + .ok() + .and_then(symbol_attribute_value) + .ok_or_else(|| attr_error(operation, attr, "symbol")) +} + pub(crate) fn symbol_array_attr( operation: OperationRef<'_, '_>, attr: &str, @@ -92,6 +103,34 @@ pub(crate) fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) .to_owned() } +pub(crate) fn operand_symbols( + operation: OperationRef<'_, '_>, + start_index: usize, +) -> Result, EmitError> { + (start_index..operation.operand_count()) + .map(|index| operand_symbol(operation, index)) + .collect() +} + +pub(crate) fn operand_symbol( + operation: OperationRef<'_, '_>, + index: usize, +) -> Result { + let operand = operation.operand(index).map_err(|_| { + EmitError::new(format!( + "{} requires operand {index}", + operation_name(operation) + )) + })?; + let owner = OperationResult::try_from(operand).map_err(|_| { + EmitError::new(format!( + "{} operand {index} must be an op result", + operation_name(operation) + )) + })?; + string_attr(owner.owner(), "sym_name") +} + fn parse_symbol_array(attribute: &str) -> Option> { let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); if inner.is_empty() { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 6354ca0ad1..e6d71c6143 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -6,6 +6,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, FieldExprDependencies, RelationOutputAst as Stage3RelationOutputAst, @@ -37,9 +38,9 @@ pub struct Stage3CpuProgram { pub relation_outputs: Vec, pub point_slices: Vec, pub point_concats: Vec, - pub opening_claims: Vec, - pub opening_equalities: Vec, - pub opening_batches: Vec, + pub opening_claims: Vec, + pub opening_equalities: Vec, + pub opening_batches: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -507,34 +508,14 @@ impl Stage3CpuProgram { }); } "cpu.opening_claim" => { - opening_claims.push(verifier_plan::CpuOpeningClaimPlan { - symbol: string_attr(op, "sym_name")?, - oracle: symbol_attr(op, "oracle")?, - domain: symbol_attr(op, "domain")?, - point_arity: int_attr(op, "point_arity")?, - claim_kind: string_attr(op, "claim_kind")?, - point_source: operand_symbol(op, 0)?, - eval_source: operand_symbol(op, 1)?, - }); + opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?); } "cpu.opening_claim_equal" => { - opening_equalities.push(verifier_plan::CpuOpeningClaimEqualityPlan { - symbol: string_attr(op, "sym_name")?, - mode: string_attr(op, "mode")?, - lhs: operand_symbol(op, 0)?, - rhs: operand_symbol(op, 1)?, - }); + opening_equalities + .push(verifier_opening_rows::CpuOpeningClaimEqualityPlan::from_cpu(op)?); } "cpu.opening_batch" => { - opening_batches.push(verifier_plan::CpuOpeningBatchPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - policy: string_attr(op, "policy")?, - count: int_attr(op, "count")?, - ordered_claims: symbol_array_attr(op, "ordered_claims")?, - claim_operands: operand_symbols(op, 0)?, - }); + opening_batches.push(verifier_opening_rows::CpuOpeningBatchPlan::from_cpu(op)?); } _ => {} } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index ea32861ea3..172dcc6a57 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -11,6 +11,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, FieldExprDependencies, RelationOutputAst as Stage4RelationOutputAst, @@ -43,9 +44,9 @@ pub struct Stage4CpuProgram { pub relation_outputs: Vec, pub point_slices: Vec, pub point_concats: Vec, - pub opening_claims: Vec, - pub opening_equalities: Vec, - pub opening_batches: Vec, + pub opening_claims: Vec, + pub opening_equalities: Vec, + pub opening_batches: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -519,34 +520,14 @@ impl Stage4CpuProgram { }); } "cpu.opening_claim" => { - opening_claims.push(verifier_plan::CpuOpeningClaimPlan { - symbol: string_attr(op, "sym_name")?, - oracle: symbol_attr(op, "oracle")?, - domain: symbol_attr(op, "domain")?, - point_arity: int_attr(op, "point_arity")?, - claim_kind: string_attr(op, "claim_kind")?, - point_source: operand_symbol(op, 0)?, - eval_source: operand_symbol(op, 1)?, - }); + opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?); } "cpu.opening_claim_equal" => { - opening_equalities.push(verifier_plan::CpuOpeningClaimEqualityPlan { - symbol: string_attr(op, "sym_name")?, - mode: string_attr(op, "mode")?, - lhs: operand_symbol(op, 0)?, - rhs: operand_symbol(op, 1)?, - }); + opening_equalities + .push(verifier_opening_rows::CpuOpeningClaimEqualityPlan::from_cpu(op)?); } "cpu.opening_batch" => { - opening_batches.push(verifier_plan::CpuOpeningBatchPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - policy: string_attr(op, "policy")?, - count: int_attr(op, "count")?, - ordered_claims: symbol_array_attr(op, "ordered_claims")?, - claim_operands: operand_symbols(op, 0)?, - }); + opening_batches.push(verifier_opening_rows::CpuOpeningBatchPlan::from_cpu(op)?); } _ => {} } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index e5be2b9bc8..a13fcbe5b4 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -16,6 +16,7 @@ use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, }; use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; +use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, @@ -57,9 +58,9 @@ pub struct Stage5CpuProgram { pub relation_outputs: Vec, pub point_slices: Vec, pub point_concats: Vec, - pub opening_claims: Vec, - pub opening_equalities: Vec, - pub opening_batches: Vec, + pub opening_claims: Vec, + pub opening_equalities: Vec, + pub opening_batches: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -579,34 +580,14 @@ impl Stage5CpuProgram { }); } "cpu.opening_claim" => { - opening_claims.push(verifier_plan::CpuOpeningClaimPlan { - symbol: string_attr(op, "sym_name")?, - oracle: symbol_attr(op, "oracle")?, - domain: symbol_attr(op, "domain")?, - point_arity: int_attr(op, "point_arity")?, - claim_kind: string_attr(op, "claim_kind")?, - point_source: operand_symbol(op, 0)?, - eval_source: operand_symbol(op, 1)?, - }); + opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?); } "cpu.opening_claim_equal" => { - opening_equalities.push(verifier_plan::CpuOpeningClaimEqualityPlan { - symbol: string_attr(op, "sym_name")?, - mode: string_attr(op, "mode")?, - lhs: operand_symbol(op, 0)?, - rhs: operand_symbol(op, 1)?, - }); + opening_equalities + .push(verifier_opening_rows::CpuOpeningClaimEqualityPlan::from_cpu(op)?); } "cpu.opening_batch" => { - opening_batches.push(verifier_plan::CpuOpeningBatchPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - policy: string_attr(op, "policy")?, - count: int_attr(op, "count")?, - ordered_claims: symbol_array_attr(op, "ordered_claims")?, - claim_operands: operand_symbols(op, 0)?, - }); + opening_batches.push(verifier_opening_rows::CpuOpeningBatchPlan::from_cpu(op)?); } _ => {} } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 152b6089da..0988ea53a4 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -17,6 +17,7 @@ use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ stage6_bytecode_read_raf_relation_output_plan, STAGE6_BYTECODE_RA_EVAL_FAMILY, }; use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; +use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, @@ -86,9 +87,9 @@ pub struct Stage6CpuProgram { pub point_zeros: Vec, pub point_slices: Vec, pub point_concats: Vec, - pub opening_claims: Vec, - pub opening_equalities: Vec, - pub opening_batches: Vec, + pub opening_claims: Vec, + pub opening_equalities: Vec, + pub opening_batches: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -592,34 +593,14 @@ impl Stage6CpuProgram { }); } "cpu.opening_claim" => { - opening_claims.push(verifier_plan::CpuOpeningClaimPlan { - symbol: string_attr(op, "sym_name")?, - oracle: symbol_attr(op, "oracle")?, - domain: symbol_attr(op, "domain")?, - point_arity: int_attr(op, "point_arity")?, - claim_kind: string_attr(op, "claim_kind")?, - point_source: operand_symbol(op, 0)?, - eval_source: operand_symbol(op, 1)?, - }); + opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?); } "cpu.opening_claim_equal" => { - opening_equalities.push(verifier_plan::CpuOpeningClaimEqualityPlan { - symbol: string_attr(op, "sym_name")?, - mode: string_attr(op, "mode")?, - lhs: operand_symbol(op, 0)?, - rhs: operand_symbol(op, 1)?, - }); + opening_equalities + .push(verifier_opening_rows::CpuOpeningClaimEqualityPlan::from_cpu(op)?); } "cpu.opening_batch" => { - opening_batches.push(verifier_plan::CpuOpeningBatchPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - policy: string_attr(op, "policy")?, - count: int_attr(op, "count")?, - ordered_claims: symbol_array_attr(op, "ordered_claims")?, - claim_operands: operand_symbols(op, 0)?, - }); + opening_batches.push(verifier_opening_rows::CpuOpeningBatchPlan::from_cpu(op)?); } _ => {} } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 92c95cbb01..c620af625a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -14,6 +14,7 @@ use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, use crate::protocols::jolt::rust_target_plan::{ power_strided_weighted_sum_formula, ScalarExprKind, }; +use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, @@ -68,9 +69,9 @@ pub struct Stage7CpuProgram { pub point_zeros: Vec, pub point_slices: Vec, pub point_concats: Vec, - pub opening_claims: Vec, - pub opening_equalities: Vec, - pub opening_batches: Vec, + pub opening_claims: Vec, + pub opening_equalities: Vec, + pub opening_batches: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -716,34 +717,14 @@ impl Stage7CpuProgram { }); } "cpu.opening_claim" => { - opening_claims.push(verifier_plan::CpuOpeningClaimPlan { - symbol: string_attr(op, "sym_name")?, - oracle: symbol_attr(op, "oracle")?, - domain: symbol_attr(op, "domain")?, - point_arity: int_attr(op, "point_arity")?, - claim_kind: string_attr(op, "claim_kind")?, - point_source: operand_symbol(op, 0)?, - eval_source: operand_symbol(op, 1)?, - }); + opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?); } "cpu.opening_claim_equal" => { - opening_equalities.push(verifier_plan::CpuOpeningClaimEqualityPlan { - symbol: string_attr(op, "sym_name")?, - mode: string_attr(op, "mode")?, - lhs: operand_symbol(op, 0)?, - rhs: operand_symbol(op, 1)?, - }); + opening_equalities + .push(verifier_opening_rows::CpuOpeningClaimEqualityPlan::from_cpu(op)?); } "cpu.opening_batch" => { - opening_batches.push(verifier_plan::CpuOpeningBatchPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - policy: string_attr(op, "policy")?, - count: int_attr(op, "count")?, - ordered_claims: symbol_array_attr(op, "ordered_claims")?, - claim_operands: operand_symbols(op, 0)?, - }); + opening_batches.push(verifier_opening_rows::CpuOpeningBatchPlan::from_cpu(op)?); } _ => {} } diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index 39b37d195c..8f2ad3f320 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -9,6 +9,7 @@ pub(crate) mod stage5_instruction_read_raf_plan; pub(crate) mod stage6_bytecode_read_raf_plan; pub mod validate; pub(crate) mod verifier_eval_families; +pub(crate) mod verifier_opening_rows; pub(crate) mod verifier_plan; pub(crate) mod verifier_relation_outputs; pub(crate) mod verifier_values; diff --git a/crates/bolt/src/protocols/jolt/verifier_opening_rows.rs b/crates/bolt/src/protocols/jolt/verifier_opening_rows.rs new file mode 100644 index 0000000000..3cee4c8106 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_opening_rows.rs @@ -0,0 +1,75 @@ +use melior::ir::OperationRef; + +use crate::emit::rust::EmitError; +use crate::protocols::jolt::cpu_attrs::{ + int_attr, operand_symbol, operand_symbols, string_attr, symbol_array_attr, symbol_attr, +}; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuOpeningClaimPlan { + pub symbol: String, + pub oracle: String, + pub domain: String, + pub point_arity: usize, + pub claim_kind: String, + pub point_source: String, + pub eval_source: String, +} + +impl CpuOpeningClaimPlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + oracle: symbol_attr(operation, "oracle")?, + domain: symbol_attr(operation, "domain")?, + point_arity: int_attr(operation, "point_arity")?, + claim_kind: string_attr(operation, "claim_kind")?, + point_source: operand_symbol(operation, 0)?, + eval_source: operand_symbol(operation, 1)?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuOpeningClaimEqualityPlan { + pub symbol: String, + pub mode: String, + pub lhs: String, + pub rhs: String, +} + +impl CpuOpeningClaimEqualityPlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + mode: string_attr(operation, "mode")?, + lhs: operand_symbol(operation, 0)?, + rhs: operand_symbol(operation, 1)?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuOpeningBatchPlan { + pub symbol: String, + pub stage: String, + pub proof_slot: String, + pub policy: String, + pub count: usize, + pub ordered_claims: Vec, + pub claim_operands: Vec, +} + +impl CpuOpeningBatchPlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + stage: symbol_attr(operation, "stage")?, + proof_slot: symbol_attr(operation, "proof_slot")?, + policy: string_attr(operation, "policy")?, + count: int_attr(operation, "count")?, + ordered_claims: symbol_array_attr(operation, "ordered_claims")?, + claim_operands: operand_symbols(operation, 0)?, + }) + } +} diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 6d07e1e0bd..fdeabc7d36 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -7,6 +7,9 @@ use crate::protocols::jolt::rust_target_plan::{ RustTargetPlanError, ScalarExprKind, SumcheckPointOrder, TranscriptSqueezeKind, }; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; +use crate::protocols::jolt::verifier_opening_rows::{ + CpuOpeningBatchPlan, CpuOpeningClaimEqualityPlan, CpuOpeningClaimPlan, +}; use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputEvalFamilyPlan, RelationOutputFunctionFamilyPlan, RelationOutputPlan, RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan, @@ -261,36 +264,6 @@ pub(crate) struct VerifierOpeningBatchPlan { pub(crate) claim_operands: Vec, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct CpuOpeningClaimPlan { - pub symbol: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, - pub point_source: String, - pub eval_source: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct CpuOpeningClaimEqualityPlan { - pub symbol: String, - pub mode: String, - pub lhs: String, - pub rhs: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct CpuOpeningBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierStagePlan { pub(crate) steps: Vec, @@ -1071,9 +1044,9 @@ macro_rules! impl_verifier_plan_source_traits { @point_exprs self $(, $point_zero)? ) } - fn opening_claims(&self) -> &[$crate::protocols::jolt::verifier_plan::CpuOpeningClaimPlan] { &self.opening_claims } - fn opening_equalities(&self) -> &[$crate::protocols::jolt::verifier_plan::CpuOpeningClaimEqualityPlan] { &self.opening_equalities } - fn opening_batches(&self) -> &[$crate::protocols::jolt::verifier_plan::CpuOpeningBatchPlan] { &self.opening_batches } + fn opening_claims(&self) -> &[$crate::protocols::jolt::verifier_opening_rows::CpuOpeningClaimPlan] { &self.opening_claims } + fn opening_equalities(&self) -> &[$crate::protocols::jolt::verifier_opening_rows::CpuOpeningClaimEqualityPlan] { &self.opening_equalities } + fn opening_batches(&self) -> &[$crate::protocols::jolt::verifier_opening_rows::CpuOpeningBatchPlan] { &self.opening_batches } } impl $crate::protocols::jolt::verifier_plan::VerifierProgramStepSource for $step { From cc273724b884bef01d5b79c4bbb099597d0c74f0 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 02:15:55 -0600 Subject: [PATCH 125/171] refactor(bolt): share cpu attr parsing Cut Stage 3-7 emitters over to the shared cpu_attrs helpers and remove duplicated local attr and operand parsers. --- crates/bolt/src/protocols/jolt/cpu_attrs.rs | 20 +++ .../src/protocols/jolt/emit/rust/stage3.rs | 143 +----------------- .../src/protocols/jolt/emit/rust/stage4.rs | 126 +-------------- .../src/protocols/jolt/emit/rust/stage5.rs | 126 +-------------- .../src/protocols/jolt/emit/rust/stage6.rs | 126 +-------------- .../src/protocols/jolt/emit/rust/stage7.rs | 126 +-------------- 6 files changed, 50 insertions(+), 617 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/cpu_attrs.rs b/crates/bolt/src/protocols/jolt/cpu_attrs.rs index 3c00a1062d..e6499a9779 100644 --- a/crates/bolt/src/protocols/jolt/cpu_attrs.rs +++ b/crates/bolt/src/protocols/jolt/cpu_attrs.rs @@ -75,6 +75,18 @@ pub(crate) fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, + attr: &str, +) -> Result { + operation + .attribute(attr) + .map(parse_signed_integer_attr) + .ok() + .flatten() + .ok_or_else(|| attr_error(operation, attr, "signed integer")) +} + pub(crate) fn int_array_attr( operation: OperationRef<'_, '_>, attr: &str, @@ -166,6 +178,14 @@ fn parse_integer_attr(attribute: Attribute<'_>) -> Option { .and_then(|value| value.parse().ok()) } +fn parse_signed_integer_attr(attribute: Attribute<'_>) -> Option { + attribute + .to_string() + .split_whitespace() + .next() + .and_then(|value| value.parse().ok()) +} + fn parse_int_array(attribute: &str) -> Option> { let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); if inner.is_empty() { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index e6d71c6143..3922b906b7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1,11 +1,14 @@ use std::collections::{BTreeMap, BTreeSet}; use melior::ir::block::BlockLike; -use melior::ir::operation::{OperationLike, OperationResult}; -use melior::ir::{Attribute, OperationRef}; +use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; -use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::ir::{BoltModule, Cpu, Role}; +use crate::protocols::jolt::cpu_attrs::{ + int_array_attr, int_attr, operand_symbol, operand_symbols, operation_name, signed_int_attr, + string_attr, symbol_array_attr, symbol_attr, +}; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ @@ -2237,137 +2240,3 @@ fn missing_role_binding(kind: &str, symbol: &str) -> EmitError { fn symbols<'a>(values: impl Iterator) -> BTreeSet { values.cloned().collect() } - -fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(string_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "string")) -} - -fn symbol_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(symbol_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "symbol")) -} - -fn symbol_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "symbol array"))?; - parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) -} - -fn parse_symbol_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned)) - .collect() -} - -fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .map(parse_integer_attr) - .ok() - .flatten() - .ok_or_else(|| attr_error(operation, attr, "integer")) -} - -fn signed_int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .map(parse_signed_integer_attr) - .ok() - .flatten() - .ok_or_else(|| attr_error(operation, attr, "signed integer")) -} - -fn parse_integer_attr(attribute: Attribute<'_>) -> Option { - attribute - .to_string() - .split_whitespace() - .next() - .and_then(|value| value.parse().ok()) -} - -fn parse_signed_integer_attr(attribute: Attribute<'_>) -> Option { - attribute - .to_string() - .split_whitespace() - .next() - .and_then(|value| value.parse().ok()) -} - -fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "integer array"))?; - parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) -} - -fn parse_int_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().parse().ok()) - .collect() -} - -fn operand_symbols( - operation: OperationRef<'_, '_>, - start_index: usize, -) -> Result, EmitError> { - (start_index..operation.operand_count()) - .map(|index| operand_symbol(operation, index)) - .collect() -} - -fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result { - let operand = operation.operand(index).map_err(|_| { - EmitError::new(format!( - "{} requires operand {index}", - operation_name(operation) - )) - })?; - let owner = OperationResult::try_from(operand).map_err(|_| { - EmitError::new(format!( - "{} operand {index} must be an op result", - operation_name(operation) - )) - })?; - string_attr(owner.owner(), "sym_name") -} - -fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError { - EmitError::new(format!( - "{} attr `{attr}` is not a {expected}", - operation_name(operation) - )) -} - -fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { - operation - .name() - .as_string_ref() - .as_str() - .unwrap_or("") - .to_owned() -} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 172dcc6a57..300a3cd675 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -6,11 +6,14 @@ use std::collections::{BTreeMap, BTreeSet}; use melior::ir::block::BlockLike; -use melior::ir::operation::{OperationLike, OperationResult}; -use melior::ir::{Attribute, OperationRef}; +use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; -use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::ir::{BoltModule, Cpu, Role}; +use crate::protocols::jolt::cpu_attrs::{ + int_array_attr, int_attr, operand_symbol, operand_symbols, operation_name, string_attr, + symbol_array_attr, symbol_attr, +}; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ @@ -2540,120 +2543,3 @@ fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Res fn symbols<'a>(values: impl Iterator) -> BTreeSet { values.cloned().collect() } - -fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(string_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "string")) -} - -fn symbol_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(symbol_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "symbol")) -} - -fn symbol_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "symbol array"))?; - parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) -} - -fn parse_symbol_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned)) - .collect() -} - -fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .map(parse_integer_attr) - .ok() - .flatten() - .ok_or_else(|| attr_error(operation, attr, "integer")) -} - -fn parse_integer_attr(attribute: Attribute<'_>) -> Option { - attribute - .to_string() - .split_whitespace() - .next() - .and_then(|value| value.parse().ok()) -} - -fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "integer array"))?; - parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) -} - -fn parse_int_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().parse().ok()) - .collect() -} - -fn operand_symbols( - operation: OperationRef<'_, '_>, - start_index: usize, -) -> Result, EmitError> { - (start_index..operation.operand_count()) - .map(|index| operand_symbol(operation, index)) - .collect() -} - -fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result { - let operand = operation.operand(index).map_err(|_| { - EmitError::new(format!( - "{} requires operand {index}", - operation_name(operation) - )) - })?; - let owner = OperationResult::try_from(operand).map_err(|_| { - EmitError::new(format!( - "{} operand {index} must be an op result", - operation_name(operation) - )) - })?; - string_attr(owner.owner(), "sym_name") -} - -fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError { - EmitError::new(format!( - "{} attr `{attr}` is not a {expected}", - operation_name(operation) - )) -} - -fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { - operation - .name() - .as_string_ref() - .as_str() - .unwrap_or("") - .to_owned() -} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index a13fcbe5b4..dacc0cd8be 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -6,11 +6,14 @@ use std::collections::{BTreeMap, BTreeSet}; use melior::ir::block::BlockLike; -use melior::ir::operation::{OperationLike, OperationResult}; -use melior::ir::{Attribute, OperationRef}; +use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; -use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::ir::{BoltModule, Cpu, Role}; +use crate::protocols::jolt::cpu_attrs::{ + int_array_attr, int_attr, operand_symbol, operand_symbols, operation_name, string_attr, + symbol_array_attr, symbol_attr, +}; use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, @@ -2628,120 +2631,3 @@ fn verify_count(kind: &str, symbol: &str, expected: usize, actual: usize) -> Res fn symbols<'a>(values: impl Iterator) -> BTreeSet { values.cloned().collect() } - -fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(string_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "string")) -} - -fn symbol_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(symbol_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "symbol")) -} - -fn symbol_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "symbol array"))?; - parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) -} - -fn parse_symbol_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned)) - .collect() -} - -fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .map(parse_integer_attr) - .ok() - .flatten() - .ok_or_else(|| attr_error(operation, attr, "integer")) -} - -fn parse_integer_attr(attribute: Attribute<'_>) -> Option { - attribute - .to_string() - .split_whitespace() - .next() - .and_then(|value| value.parse().ok()) -} - -fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "integer array"))?; - parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) -} - -fn parse_int_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().parse().ok()) - .collect() -} - -fn operand_symbols( - operation: OperationRef<'_, '_>, - start_index: usize, -) -> Result, EmitError> { - (start_index..operation.operand_count()) - .map(|index| operand_symbol(operation, index)) - .collect() -} - -fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result { - let operand = operation.operand(index).map_err(|_| { - EmitError::new(format!( - "{} requires operand {index}", - operation_name(operation) - )) - })?; - let owner = OperationResult::try_from(operand).map_err(|_| { - EmitError::new(format!( - "{} operand {index} must be an op result", - operation_name(operation) - )) - })?; - string_attr(owner.owner(), "sym_name") -} - -fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError { - EmitError::new(format!( - "{} attr `{attr}` is not a {expected}", - operation_name(operation) - )) -} - -fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { - operation - .name() - .as_string_ref() - .as_str() - .unwrap_or("") - .to_owned() -} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 0988ea53a4..9c1ae248ab 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -6,11 +6,14 @@ use std::collections::BTreeMap; use melior::ir::block::BlockLike; -use melior::ir::operation::{OperationLike, OperationResult}; -use melior::ir::{Attribute, OperationRef}; +use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; -use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::ir::{BoltModule, Cpu, Role}; +use crate::protocols::jolt::cpu_attrs::{ + int_array_attr, int_attr, operand_symbol, operand_symbols, operation_name, string_attr, + symbol_array_attr, symbol_attr, +}; use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, @@ -2804,123 +2807,6 @@ fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi)) } -fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(string_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "string")) -} - -fn symbol_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(symbol_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "symbol")) -} - -fn symbol_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "symbol array"))?; - parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) -} - -fn parse_symbol_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned)) - .collect() -} - -fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .map(parse_integer_attr) - .ok() - .flatten() - .ok_or_else(|| attr_error(operation, attr, "integer")) -} - -fn parse_integer_attr(attribute: Attribute<'_>) -> Option { - attribute - .to_string() - .split_whitespace() - .next() - .and_then(|value| value.parse().ok()) -} - -fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "integer array"))?; - parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) -} - -fn parse_int_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().parse().ok()) - .collect() -} - -fn operand_symbols( - operation: OperationRef<'_, '_>, - start_index: usize, -) -> Result, EmitError> { - (start_index..operation.operand_count()) - .map(|index| operand_symbol(operation, index)) - .collect() -} - -fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result { - let operand = operation.operand(index).map_err(|_| { - EmitError::new(format!( - "{} requires operand {index}", - operation_name(operation) - )) - })?; - let owner = OperationResult::try_from(operand).map_err(|_| { - EmitError::new(format!( - "{} operand {index} must be an op result", - operation_name(operation) - )) - })?; - string_attr(owner.owner(), "sym_name") -} - -fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError { - EmitError::new(format!( - "{} attr `{attr}` is not a {expected}", - operation_name(operation) - )) -} - -fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { - operation - .name() - .as_string_ref() - .as_str() - .unwrap_or("") - .to_owned() -} - #[cfg(test)] mod tests { use crate::emit::rust::EmitError; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index c620af625a..bd00a33a07 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -6,11 +6,14 @@ use std::collections::BTreeMap; use melior::ir::block::BlockLike; -use melior::ir::operation::{OperationLike, OperationResult}; -use melior::ir::{Attribute, OperationRef}; +use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; -use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; +use crate::ir::{BoltModule, Cpu, Role}; +use crate::protocols::jolt::cpu_attrs::{ + int_array_attr, int_attr, operand_symbol, operand_symbols, operation_name, string_attr, + symbol_array_attr, symbol_attr, +}; use crate::protocols::jolt::rust_target_plan::{ power_strided_weighted_sum_formula, ScalarExprKind, }; @@ -2689,123 +2692,6 @@ fn stage7_kernel_abi(relation: &str) -> Option<&'static str> { .find_map(|(candidate, abi)| (*candidate == relation).then_some(*abi)) } -fn string_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(string_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "string")) -} - -fn symbol_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .ok() - .and_then(symbol_attribute_value) - .ok_or_else(|| attr_error(operation, attr, "symbol")) -} - -fn symbol_array_attr( - operation: OperationRef<'_, '_>, - attr: &str, -) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "symbol array"))?; - parse_symbol_array(&attribute).ok_or_else(|| attr_error(operation, attr, "symbol array")) -} - -fn parse_symbol_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().strip_prefix('@').map(ToOwned::to_owned)) - .collect() -} - -fn int_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result { - operation - .attribute(attr) - .map(parse_integer_attr) - .ok() - .flatten() - .ok_or_else(|| attr_error(operation, attr, "integer")) -} - -fn parse_integer_attr(attribute: Attribute<'_>) -> Option { - attribute - .to_string() - .split_whitespace() - .next() - .and_then(|value| value.parse().ok()) -} - -fn int_array_attr(operation: OperationRef<'_, '_>, attr: &str) -> Result, EmitError> { - let attribute = operation - .attribute(attr) - .map(|attribute| attribute.to_string()) - .ok() - .ok_or_else(|| attr_error(operation, attr, "integer array"))?; - parse_int_array(&attribute).ok_or_else(|| attr_error(operation, attr, "integer array")) -} - -fn parse_int_array(attribute: &str) -> Option> { - let inner = attribute.strip_prefix('[')?.strip_suffix(']')?.trim(); - if inner.is_empty() { - return Some(Vec::new()); - } - inner - .split(',') - .map(|item| item.trim().parse().ok()) - .collect() -} - -fn operand_symbols( - operation: OperationRef<'_, '_>, - start_index: usize, -) -> Result, EmitError> { - (start_index..operation.operand_count()) - .map(|index| operand_symbol(operation, index)) - .collect() -} - -fn operand_symbol(operation: OperationRef<'_, '_>, index: usize) -> Result { - let operand = operation.operand(index).map_err(|_| { - EmitError::new(format!( - "{} requires operand {index}", - operation_name(operation) - )) - })?; - let owner = OperationResult::try_from(operand).map_err(|_| { - EmitError::new(format!( - "{} operand {index} must be an op result", - operation_name(operation) - )) - })?; - string_attr(owner.owner(), "sym_name") -} - -fn attr_error(operation: OperationRef<'_, '_>, attr: &str, expected: &str) -> EmitError { - EmitError::new(format!( - "{} attr `{attr}` is not a {expected}", - operation_name(operation) - )) -} - -fn operation_name<'c: 'a, 'a>(operation: impl OperationLike<'c, 'a>) -> String { - operation - .name() - .as_string_ref() - .as_str() - .unwrap_or("") - .to_owned() -} - #[cfg(test)] mod tests { use super::{stage7_kernel_abi, STAGE7_KERNEL_ABIS}; From 27a778b200ab7801cb18a7beb19658119896966e Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 02:33:02 -0600 Subject: [PATCH 126/171] refactor(bolt): centralize sumcheck parsing --- .../src/protocols/jolt/emit/rust/stage3.rs | 189 ++---------- .../src/protocols/jolt/emit/rust/stage4.rs | 189 ++---------- .../src/protocols/jolt/emit/rust/stage5.rs | 189 ++---------- .../src/protocols/jolt/emit/rust/stage6.rs | 189 ++---------- .../src/protocols/jolt/emit/rust/stage7.rs | 191 ++---------- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../bolt/src/protocols/jolt/verifier_plan.rs | 279 ++++++++++++------ .../protocols/jolt/verifier_sumcheck_rows.rs | 188 ++++++++++++ 8 files changed, 501 insertions(+), 914 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_sumcheck_rows.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 3922b906b7..2056a3ce3a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -6,8 +6,8 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_array_attr, int_attr, operand_symbol, operand_symbols, operation_name, signed_int_attr, - string_attr, symbol_array_attr, symbol_attr, + int_attr, operand_symbol, operand_symbols, operation_name, signed_int_attr, string_attr, + symbol_array_attr, symbol_attr, }; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; @@ -17,6 +17,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputPlan as Stage3RelationOutputPlan, StructuredPolynomialEvalPlan as Stage3StructuredPolynomialEvalPlan, }; +use crate::protocols::jolt::verifier_sumcheck_rows; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -32,11 +33,11 @@ pub struct Stage3CpuProgram { pub field_exprs: Vec, pub scalar_exprs: Vec, pub kernels: Vec, - pub claims: Vec, - pub batches: Vec, - pub drivers: Vec, - pub instance_results: Vec, - pub evals: Vec, + pub claims: Vec, + pub batches: Vec, + pub drivers: Vec, + pub instance_results: Vec, + pub evals: Vec, pub relation_output_values: Vec, pub relation_outputs: Vec, pub point_slices: Vec, @@ -132,73 +133,6 @@ fn stage3_scalar_expr(expr: Stage3RelationOutputFieldExprPlan) -> Stage3ScalarEx } } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3SumcheckClaimPlan { - pub symbol: String, - pub stage: String, - pub domain: String, - pub num_rounds: usize, - pub degree: usize, - pub claim: String, - pub kernel: Option, - pub relation: Option, - pub claim_value: String, - pub input_openings: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3SumcheckBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, - pub claim_label: String, - pub round_label: String, - pub round_schedule: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3SumcheckDriverPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub kernel: Option, - pub relation: Option, - pub batch: String, - pub policy: String, - pub round_schedule: Vec, - pub claim_label: String, - pub round_label: String, - pub num_rounds: usize, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3SumcheckInstanceResultPlan { - pub symbol: String, - pub source: String, - pub claim: String, - pub relation: String, - pub index: usize, - pub point_arity: usize, - pub num_rounds: usize, - pub round_offset: usize, - pub point_order: String, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3SumcheckEvalPlan { - pub symbol: String, - pub source: String, - pub name: String, - pub index: usize, - pub oracle: String, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage3PointSlicePlan { pub symbol: String, @@ -224,11 +158,6 @@ verifier_plan::impl_verifier_plan_source_traits!( field_constant = Stage3FieldConstantPlan, field_expr = Stage3FieldExprPlan, scalar_expr = Stage3ScalarExprPlan, - claim = Stage3SumcheckClaimPlan, - batch = Stage3SumcheckBatchPlan, - driver = Stage3SumcheckDriverPlan, - instance = Stage3SumcheckInstanceResultPlan, - eval = Stage3SumcheckEvalPlan, point_slice = Stage3PointSlicePlan, point_concat = Stage3PointConcatPlan, ); @@ -374,111 +303,39 @@ impl Stage3CpuProgram { }); } "cpu.sumcheck_claim" => { - claims.push(Stage3SumcheckClaimPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - domain: symbol_attr(op, "domain")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, - claim: symbol_attr(op, "claim")?, - kernel: Some(symbol_attr(op, "kernel")?), - relation: None, - claim_value: operand_symbol(op, 0)?, - input_openings: operand_symbols(op, 1)?, - }); + claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim( + op, + )?); } "cpu.sumcheck_verify_claim" => { - claims.push(Stage3SumcheckClaimPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - domain: symbol_attr(op, "domain")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, - claim: symbol_attr(op, "claim")?, - kernel: None, - relation: Some(symbol_attr(op, "relation")?), - claim_value: operand_symbol(op, 0)?, - input_openings: operand_symbols(op, 1)?, - }); + claims + .push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_verify_claim(op)?); } "cpu.sumcheck_batch" => { - batches.push(Stage3SumcheckBatchPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - policy: string_attr(op, "policy")?, - count: int_attr(op, "count")?, - ordered_claims: symbol_array_attr(op, "ordered_claims")?, - claim_operands: operand_symbols(op, 0)?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - round_schedule: int_array_attr(op, "round_schedule")?, - }); + batches.push(verifier_sumcheck_rows::CpuSumcheckBatchPlan::from_cpu(op)?); } "cpu.sumcheck_driver" => { - let symbol = string_attr(op, "sym_name")?; + let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?; steps.push(Stage3ProgramStepPlan { kind: "sumcheck_driver".to_owned(), - symbol: symbol.clone(), - }); - drivers.push(Stage3SumcheckDriverPlan { - symbol, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - kernel: Some(symbol_attr(op, "kernel")?), - relation: None, - batch: operand_symbol(op, 1)?, - policy: string_attr(op, "policy")?, - round_schedule: int_array_attr(op, "round_schedule")?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, + symbol: driver.symbol.clone(), }); + drivers.push(driver); } "cpu.sumcheck_verify" => { - let symbol = string_attr(op, "sym_name")?; + let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?; steps.push(Stage3ProgramStepPlan { kind: "sumcheck_driver".to_owned(), - symbol: symbol.clone(), - }); - drivers.push(Stage3SumcheckDriverPlan { - symbol, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - kernel: None, - relation: Some(symbol_attr(op, "relation")?), - batch: operand_symbol(op, 1)?, - policy: string_attr(op, "policy")?, - round_schedule: int_array_attr(op, "round_schedule")?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, + symbol: driver.symbol.clone(), }); + drivers.push(driver); } "cpu.sumcheck_instance_result" => { - instance_results.push(Stage3SumcheckInstanceResultPlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - claim: symbol_attr(op, "claim")?, - relation: symbol_attr(op, "relation")?, - index: int_attr(op, "index")?, - point_arity: int_attr(op, "point_arity")?, - num_rounds: int_attr(op, "num_rounds")?, - round_offset: int_attr(op, "round_offset")?, - point_order: string_attr(op, "point_order")?, - degree: int_attr(op, "degree")?, - }); + instance_results + .push(verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan::from_cpu(op)?); } "cpu.sumcheck_eval" => { - evals.push(Stage3SumcheckEvalPlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - name: symbol_attr(op, "name")?, - index: int_attr(op, "index")?, - oracle: symbol_attr(op, "oracle")?, - }); + evals.push(verifier_sumcheck_rows::CpuSumcheckEvalPlan::from_cpu(op)?); } "cpu.structured_polynomial_eval" => { relation_output_values.push( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 300a3cd675..c9c2cb0f9d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -11,8 +11,8 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_array_attr, int_attr, operand_symbol, operand_symbols, operation_name, string_attr, - symbol_array_attr, symbol_attr, + int_attr, operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, + symbol_attr, }; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; @@ -22,6 +22,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputPlan as Stage4RelationOutputPlan, StructuredPolynomialEvalPlan as Stage4StructuredPolynomialEvalPlan, }; +use crate::protocols::jolt::verifier_sumcheck_rows; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -38,11 +39,11 @@ pub struct Stage4CpuProgram { pub field_exprs: Vec, pub scalar_exprs: Vec, pub kernels: Vec, - pub claims: Vec, - pub batches: Vec, - pub drivers: Vec, - pub instance_results: Vec, - pub evals: Vec, + pub claims: Vec, + pub batches: Vec, + pub drivers: Vec, + pub instance_results: Vec, + pub evals: Vec, pub relation_output_values: Vec, pub relation_outputs: Vec, pub point_slices: Vec, @@ -145,73 +146,6 @@ fn stage4_scalar_expr(expr: Stage4RelationOutputFieldExprPlan) -> Stage4ScalarEx } } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4SumcheckClaimPlan { - pub symbol: String, - pub stage: String, - pub domain: String, - pub num_rounds: usize, - pub degree: usize, - pub claim: String, - pub kernel: Option, - pub relation: Option, - pub claim_value: String, - pub input_openings: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4SumcheckBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, - pub claim_label: String, - pub round_label: String, - pub round_schedule: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4SumcheckDriverPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub kernel: Option, - pub relation: Option, - pub batch: String, - pub policy: String, - pub round_schedule: Vec, - pub claim_label: String, - pub round_label: String, - pub num_rounds: usize, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4SumcheckInstanceResultPlan { - pub symbol: String, - pub source: String, - pub claim: String, - pub relation: String, - pub index: usize, - pub point_arity: usize, - pub num_rounds: usize, - pub round_offset: usize, - pub point_order: String, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4SumcheckEvalPlan { - pub symbol: String, - pub source: String, - pub name: String, - pub index: usize, - pub oracle: String, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage4PointSlicePlan { pub symbol: String, @@ -237,11 +171,6 @@ verifier_plan::impl_verifier_plan_source_traits!( field_constant = Stage4FieldConstantPlan, field_expr = Stage4FieldExprPlan, scalar_expr = Stage4ScalarExprPlan, - claim = Stage4SumcheckClaimPlan, - batch = Stage4SumcheckBatchPlan, - driver = Stage4SumcheckDriverPlan, - instance = Stage4SumcheckInstanceResultPlan, - eval = Stage4SumcheckEvalPlan, point_slice = Stage4PointSlicePlan, point_concat = Stage4PointConcatPlan, absorb = Stage4TranscriptAbsorbBytesPlan, @@ -386,111 +315,39 @@ impl Stage4CpuProgram { }); } "cpu.sumcheck_claim" => { - claims.push(Stage4SumcheckClaimPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - domain: symbol_attr(op, "domain")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, - claim: symbol_attr(op, "claim")?, - kernel: Some(symbol_attr(op, "kernel")?), - relation: None, - claim_value: operand_symbol(op, 0)?, - input_openings: operand_symbols(op, 1)?, - }); + claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim( + op, + )?); } "cpu.sumcheck_verify_claim" => { - claims.push(Stage4SumcheckClaimPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - domain: symbol_attr(op, "domain")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, - claim: symbol_attr(op, "claim")?, - kernel: None, - relation: Some(symbol_attr(op, "relation")?), - claim_value: operand_symbol(op, 0)?, - input_openings: operand_symbols(op, 1)?, - }); + claims + .push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_verify_claim(op)?); } "cpu.sumcheck_batch" => { - batches.push(Stage4SumcheckBatchPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - policy: string_attr(op, "policy")?, - count: int_attr(op, "count")?, - ordered_claims: symbol_array_attr(op, "ordered_claims")?, - claim_operands: operand_symbols(op, 0)?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - round_schedule: int_array_attr(op, "round_schedule")?, - }); + batches.push(verifier_sumcheck_rows::CpuSumcheckBatchPlan::from_cpu(op)?); } "cpu.sumcheck_driver" => { - let symbol = string_attr(op, "sym_name")?; + let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?; steps.push(Stage4ProgramStepPlan { kind: "sumcheck_driver".to_owned(), - symbol: symbol.clone(), - }); - drivers.push(Stage4SumcheckDriverPlan { - symbol, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - kernel: Some(symbol_attr(op, "kernel")?), - relation: None, - batch: operand_symbol(op, 1)?, - policy: string_attr(op, "policy")?, - round_schedule: int_array_attr(op, "round_schedule")?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, + symbol: driver.symbol.clone(), }); + drivers.push(driver); } "cpu.sumcheck_verify" => { - let symbol = string_attr(op, "sym_name")?; + let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?; steps.push(Stage4ProgramStepPlan { kind: "sumcheck_driver".to_owned(), - symbol: symbol.clone(), - }); - drivers.push(Stage4SumcheckDriverPlan { - symbol, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - kernel: None, - relation: Some(symbol_attr(op, "relation")?), - batch: operand_symbol(op, 1)?, - policy: string_attr(op, "policy")?, - round_schedule: int_array_attr(op, "round_schedule")?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, + symbol: driver.symbol.clone(), }); + drivers.push(driver); } "cpu.sumcheck_instance_result" => { - instance_results.push(Stage4SumcheckInstanceResultPlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - claim: symbol_attr(op, "claim")?, - relation: symbol_attr(op, "relation")?, - index: int_attr(op, "index")?, - point_arity: int_attr(op, "point_arity")?, - num_rounds: int_attr(op, "num_rounds")?, - round_offset: int_attr(op, "round_offset")?, - point_order: string_attr(op, "point_order")?, - degree: int_attr(op, "degree")?, - }); + instance_results + .push(verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan::from_cpu(op)?); } "cpu.sumcheck_eval" => { - evals.push(Stage4SumcheckEvalPlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - name: symbol_attr(op, "name")?, - index: int_attr(op, "index")?, - oracle: symbol_attr(op, "oracle")?, - }); + evals.push(verifier_sumcheck_rows::CpuSumcheckEvalPlan::from_cpu(op)?); } "cpu.structured_polynomial_eval" => { relation_output_values.push( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index dacc0cd8be..6be368e006 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -11,8 +11,8 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_array_attr, int_attr, operand_symbol, operand_symbols, operation_name, string_attr, - symbol_array_attr, symbol_attr, + int_attr, operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, + symbol_attr, }; use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ @@ -32,6 +32,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputProductFamilyPlan as Stage5RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, }; +use crate::protocols::jolt::verifier_sumcheck_rows; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -49,11 +50,11 @@ pub struct Stage5CpuProgram { pub field_exprs: Vec, pub scalar_exprs: Vec, pub kernels: Vec, - pub claims: Vec, - pub batches: Vec, - pub drivers: Vec, - pub instance_results: Vec, - pub evals: Vec, + pub claims: Vec, + pub batches: Vec, + pub drivers: Vec, + pub instance_results: Vec, + pub evals: Vec, pub relation_output_values: Vec, pub relation_output_eval_families: Vec, pub relation_output_product_families: Vec, @@ -149,73 +150,6 @@ impl FieldExprDependencies for Stage5FieldExprPlan { } } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5SumcheckClaimPlan { - pub symbol: String, - pub stage: String, - pub domain: String, - pub num_rounds: usize, - pub degree: usize, - pub claim: String, - pub kernel: Option, - pub relation: Option, - pub claim_value: String, - pub input_openings: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5SumcheckBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, - pub claim_label: String, - pub round_label: String, - pub round_schedule: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5SumcheckDriverPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub kernel: Option, - pub relation: Option, - pub batch: String, - pub policy: String, - pub round_schedule: Vec, - pub claim_label: String, - pub round_label: String, - pub num_rounds: usize, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5SumcheckInstanceResultPlan { - pub symbol: String, - pub source: String, - pub claim: String, - pub relation: String, - pub index: usize, - pub point_arity: usize, - pub num_rounds: usize, - pub round_offset: usize, - pub point_order: String, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5SumcheckEvalPlan { - pub symbol: String, - pub source: String, - pub name: String, - pub index: usize, - pub oracle: String, -} - fn stage5_field_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage5FieldExprPlan { Stage5FieldExprPlan { symbol: expr.symbol, @@ -273,11 +207,6 @@ verifier_plan::impl_verifier_plan_source_traits!( field_constant = Stage5FieldConstantPlan, field_expr = Stage5FieldExprPlan, scalar_expr = Stage5ScalarExprPlan, - claim = Stage5SumcheckClaimPlan, - batch = Stage5SumcheckBatchPlan, - driver = Stage5SumcheckDriverPlan, - instance = Stage5SumcheckInstanceResultPlan, - eval = Stage5SumcheckEvalPlan, point_slice = Stage5PointSlicePlan, point_concat = Stage5PointConcatPlan, absorb = Stage5TranscriptAbsorbBytesPlan, @@ -430,111 +359,39 @@ impl Stage5CpuProgram { }); } "cpu.sumcheck_claim" => { - claims.push(Stage5SumcheckClaimPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - domain: symbol_attr(op, "domain")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, - claim: symbol_attr(op, "claim")?, - kernel: Some(symbol_attr(op, "kernel")?), - relation: None, - claim_value: operand_symbol(op, 0)?, - input_openings: operand_symbols(op, 1)?, - }); + claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim( + op, + )?); } "cpu.sumcheck_verify_claim" => { - claims.push(Stage5SumcheckClaimPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - domain: symbol_attr(op, "domain")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, - claim: symbol_attr(op, "claim")?, - kernel: None, - relation: Some(symbol_attr(op, "relation")?), - claim_value: operand_symbol(op, 0)?, - input_openings: operand_symbols(op, 1)?, - }); + claims + .push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_verify_claim(op)?); } "cpu.sumcheck_batch" => { - batches.push(Stage5SumcheckBatchPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - policy: string_attr(op, "policy")?, - count: int_attr(op, "count")?, - ordered_claims: symbol_array_attr(op, "ordered_claims")?, - claim_operands: operand_symbols(op, 0)?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - round_schedule: int_array_attr(op, "round_schedule")?, - }); + batches.push(verifier_sumcheck_rows::CpuSumcheckBatchPlan::from_cpu(op)?); } "cpu.sumcheck_driver" => { - let symbol = string_attr(op, "sym_name")?; + let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?; steps.push(Stage5ProgramStepPlan { kind: "sumcheck_driver".to_owned(), - symbol: symbol.clone(), - }); - drivers.push(Stage5SumcheckDriverPlan { - symbol, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - kernel: Some(symbol_attr(op, "kernel")?), - relation: None, - batch: operand_symbol(op, 1)?, - policy: string_attr(op, "policy")?, - round_schedule: int_array_attr(op, "round_schedule")?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, + symbol: driver.symbol.clone(), }); + drivers.push(driver); } "cpu.sumcheck_verify" => { - let symbol = string_attr(op, "sym_name")?; + let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?; steps.push(Stage5ProgramStepPlan { kind: "sumcheck_driver".to_owned(), - symbol: symbol.clone(), - }); - drivers.push(Stage5SumcheckDriverPlan { - symbol, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - kernel: None, - relation: Some(symbol_attr(op, "relation")?), - batch: operand_symbol(op, 1)?, - policy: string_attr(op, "policy")?, - round_schedule: int_array_attr(op, "round_schedule")?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, + symbol: driver.symbol.clone(), }); + drivers.push(driver); } "cpu.sumcheck_instance_result" => { - instance_results.push(Stage5SumcheckInstanceResultPlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - claim: symbol_attr(op, "claim")?, - relation: symbol_attr(op, "relation")?, - index: int_attr(op, "index")?, - point_arity: int_attr(op, "point_arity")?, - num_rounds: int_attr(op, "num_rounds")?, - round_offset: int_attr(op, "round_offset")?, - point_order: string_attr(op, "point_order")?, - degree: int_attr(op, "degree")?, - }); + instance_results + .push(verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan::from_cpu(op)?); } "cpu.sumcheck_eval" => { - evals.push(Stage5SumcheckEvalPlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - name: symbol_attr(op, "name")?, - index: int_attr(op, "index")?, - oracle: symbol_attr(op, "oracle")?, - }); + evals.push(verifier_sumcheck_rows::CpuSumcheckEvalPlan::from_cpu(op)?); } "cpu.sumcheck_eval_family" => { indexed_eval_families diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 9c1ae248ab..d014c4f831 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -11,8 +11,8 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_array_attr, int_attr, operand_symbol, operand_symbols, operation_name, string_attr, - symbol_array_attr, symbol_attr, + int_attr, operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, + symbol_attr, }; use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ @@ -33,6 +33,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputProductFamilyPlan as Stage6RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan, }; +use crate::protocols::jolt::verifier_sumcheck_rows; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -77,11 +78,11 @@ pub struct Stage6CpuProgram { pub field_exprs: Vec, pub scalar_exprs: Vec, pub kernels: Vec, - pub claims: Vec, - pub batches: Vec, - pub drivers: Vec, - pub instance_results: Vec, - pub evals: Vec, + pub claims: Vec, + pub batches: Vec, + pub drivers: Vec, + pub instance_results: Vec, + pub evals: Vec, pub relation_output_values: Vec, pub relation_output_eval_families: Vec, pub relation_output_product_families: Vec, @@ -178,73 +179,6 @@ impl FieldExprDependencies for Stage6FieldExprPlan { } } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6SumcheckClaimPlan { - pub symbol: String, - pub stage: String, - pub domain: String, - pub num_rounds: usize, - pub degree: usize, - pub claim: String, - pub kernel: Option, - pub relation: Option, - pub claim_value: String, - pub input_openings: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6SumcheckBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, - pub claim_label: String, - pub round_label: String, - pub round_schedule: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6SumcheckDriverPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub kernel: Option, - pub relation: Option, - pub batch: String, - pub policy: String, - pub round_schedule: Vec, - pub claim_label: String, - pub round_label: String, - pub num_rounds: usize, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6SumcheckInstanceResultPlan { - pub symbol: String, - pub source: String, - pub claim: String, - pub relation: String, - pub index: usize, - pub point_arity: usize, - pub num_rounds: usize, - pub round_offset: usize, - pub point_order: String, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6SumcheckEvalPlan { - pub symbol: String, - pub source: String, - pub name: String, - pub index: usize, - pub oracle: String, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage6PointZeroPlan { pub symbol: String, @@ -277,11 +211,6 @@ verifier_plan::impl_verifier_plan_source_traits!( field_constant = Stage6FieldConstantPlan, field_expr = Stage6FieldExprPlan, scalar_expr = Stage6ScalarExprPlan, - claim = Stage6SumcheckClaimPlan, - batch = Stage6SumcheckBatchPlan, - driver = Stage6SumcheckDriverPlan, - instance = Stage6SumcheckInstanceResultPlan, - eval = Stage6SumcheckEvalPlan, point_slice = Stage6PointSlicePlan, point_concat = Stage6PointConcatPlan, absorb = Stage6TranscriptAbsorbBytesPlan, @@ -436,111 +365,39 @@ impl Stage6CpuProgram { }); } "cpu.sumcheck_claim" => { - claims.push(Stage6SumcheckClaimPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - domain: symbol_attr(op, "domain")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, - claim: symbol_attr(op, "claim")?, - kernel: Some(symbol_attr(op, "kernel")?), - relation: None, - claim_value: operand_symbol(op, 0)?, - input_openings: operand_symbols(op, 1)?, - }); + claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim( + op, + )?); } "cpu.sumcheck_verify_claim" => { - claims.push(Stage6SumcheckClaimPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - domain: symbol_attr(op, "domain")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, - claim: symbol_attr(op, "claim")?, - kernel: None, - relation: Some(symbol_attr(op, "relation")?), - claim_value: operand_symbol(op, 0)?, - input_openings: operand_symbols(op, 1)?, - }); + claims + .push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_verify_claim(op)?); } "cpu.sumcheck_batch" => { - batches.push(Stage6SumcheckBatchPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - policy: string_attr(op, "policy")?, - count: int_attr(op, "count")?, - ordered_claims: symbol_array_attr(op, "ordered_claims")?, - claim_operands: operand_symbols(op, 0)?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - round_schedule: int_array_attr(op, "round_schedule")?, - }); + batches.push(verifier_sumcheck_rows::CpuSumcheckBatchPlan::from_cpu(op)?); } "cpu.sumcheck_driver" => { - let symbol = string_attr(op, "sym_name")?; + let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?; steps.push(Stage6ProgramStepPlan { kind: "sumcheck_driver".to_owned(), - symbol: symbol.clone(), - }); - drivers.push(Stage6SumcheckDriverPlan { - symbol, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - kernel: Some(symbol_attr(op, "kernel")?), - relation: None, - batch: operand_symbol(op, 1)?, - policy: string_attr(op, "policy")?, - round_schedule: int_array_attr(op, "round_schedule")?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, + symbol: driver.symbol.clone(), }); + drivers.push(driver); } "cpu.sumcheck_verify" => { - let symbol = string_attr(op, "sym_name")?; + let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?; steps.push(Stage6ProgramStepPlan { kind: "sumcheck_driver".to_owned(), - symbol: symbol.clone(), - }); - drivers.push(Stage6SumcheckDriverPlan { - symbol, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - kernel: None, - relation: Some(symbol_attr(op, "relation")?), - batch: operand_symbol(op, 1)?, - policy: string_attr(op, "policy")?, - round_schedule: int_array_attr(op, "round_schedule")?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, + symbol: driver.symbol.clone(), }); + drivers.push(driver); } "cpu.sumcheck_instance_result" => { - instance_results.push(Stage6SumcheckInstanceResultPlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - claim: symbol_attr(op, "claim")?, - relation: symbol_attr(op, "relation")?, - index: int_attr(op, "index")?, - point_arity: int_attr(op, "point_arity")?, - num_rounds: int_attr(op, "num_rounds")?, - round_offset: int_attr(op, "round_offset")?, - point_order: string_attr(op, "point_order")?, - degree: int_attr(op, "degree")?, - }); + instance_results + .push(verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan::from_cpu(op)?); } "cpu.sumcheck_eval" => { - evals.push(Stage6SumcheckEvalPlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - name: symbol_attr(op, "name")?, - index: int_attr(op, "index")?, - oracle: symbol_attr(op, "oracle")?, - }); + evals.push(verifier_sumcheck_rows::CpuSumcheckEvalPlan::from_cpu(op)?); } "cpu.sumcheck_eval_family" => { indexed_eval_families diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index bd00a33a07..8fd9f52749 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -11,8 +11,8 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_array_attr, int_attr, operand_symbol, operand_symbols, operation_name, string_attr, - symbol_array_attr, symbol_attr, + int_attr, operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, + symbol_attr, }; use crate::protocols::jolt::rust_target_plan::{ power_strided_weighted_sum_formula, ScalarExprKind, @@ -30,6 +30,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputProductFamilyPlan as Stage7RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan, }; +use crate::protocols::jolt::verifier_sumcheck_rows; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -59,11 +60,11 @@ pub struct Stage7CpuProgram { pub field_exprs: Vec, pub scalar_exprs: Vec, pub kernels: Vec, - pub claims: Vec, - pub batches: Vec, - pub drivers: Vec, - pub instance_results: Vec, - pub evals: Vec, + pub claims: Vec, + pub batches: Vec, + pub drivers: Vec, + pub instance_results: Vec, + pub evals: Vec, pub relation_output_values: Vec, pub relation_output_eval_families: Vec, pub relation_output_product_families: Vec, @@ -189,7 +190,7 @@ struct HammingWeightClaimRow { fn compact_hamming_weight_input_claim( field_exprs: &mut Vec, scalar_exprs: &mut Vec, - claims: &mut [Stage7SumcheckClaimPlan], + claims: &mut [verifier_sumcheck_rows::CpuSumcheckClaimPlan], opening_inputs: &[Stage7OpeningInputPlan], ) -> Result<(), EmitError> { let Some(claim) = claims @@ -308,73 +309,6 @@ fn is_hamming_weight_input_claim_expr(symbol: &str) -> bool { || symbol.starts_with("stage7.hamming_weight_claim_reduction.claim_expr") } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7SumcheckClaimPlan { - pub symbol: String, - pub stage: String, - pub domain: String, - pub num_rounds: usize, - pub degree: usize, - pub claim: String, - pub kernel: Option, - pub relation: Option, - pub claim_value: String, - pub input_openings: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7SumcheckBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, - pub claim_label: String, - pub round_label: String, - pub round_schedule: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7SumcheckDriverPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub kernel: Option, - pub relation: Option, - pub batch: String, - pub policy: String, - pub round_schedule: Vec, - pub claim_label: String, - pub round_label: String, - pub num_rounds: usize, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7SumcheckInstanceResultPlan { - pub symbol: String, - pub source: String, - pub claim: String, - pub relation: String, - pub index: usize, - pub point_arity: usize, - pub num_rounds: usize, - pub round_offset: usize, - pub point_order: String, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7SumcheckEvalPlan { - pub symbol: String, - pub source: String, - pub name: String, - pub index: usize, - pub oracle: String, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage7PointZeroPlan { pub symbol: String, @@ -407,11 +341,6 @@ verifier_plan::impl_verifier_plan_source_traits!( field_constant = Stage7FieldConstantPlan, field_expr = Stage7FieldExprPlan, scalar_expr = Stage7ScalarExprPlan, - claim = Stage7SumcheckClaimPlan, - batch = Stage7SumcheckBatchPlan, - driver = Stage7SumcheckDriverPlan, - instance = Stage7SumcheckInstanceResultPlan, - eval = Stage7SumcheckEvalPlan, point_slice = Stage7PointSlicePlan, point_concat = Stage7PointConcatPlan, absorb = Stage7TranscriptAbsorbBytesPlan, @@ -564,111 +493,39 @@ impl Stage7CpuProgram { }); } "cpu.sumcheck_claim" => { - claims.push(Stage7SumcheckClaimPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - domain: symbol_attr(op, "domain")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, - claim: symbol_attr(op, "claim")?, - kernel: Some(symbol_attr(op, "kernel")?), - relation: None, - claim_value: operand_symbol(op, 0)?, - input_openings: operand_symbols(op, 1)?, - }); + claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim( + op, + )?); } "cpu.sumcheck_verify_claim" => { - claims.push(Stage7SumcheckClaimPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - domain: symbol_attr(op, "domain")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, - claim: symbol_attr(op, "claim")?, - kernel: None, - relation: Some(symbol_attr(op, "relation")?), - claim_value: operand_symbol(op, 0)?, - input_openings: operand_symbols(op, 1)?, - }); + claims + .push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_verify_claim(op)?); } "cpu.sumcheck_batch" => { - batches.push(Stage7SumcheckBatchPlan { - symbol: string_attr(op, "sym_name")?, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - policy: string_attr(op, "policy")?, - count: int_attr(op, "count")?, - ordered_claims: symbol_array_attr(op, "ordered_claims")?, - claim_operands: operand_symbols(op, 0)?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - round_schedule: int_array_attr(op, "round_schedule")?, - }); + batches.push(verifier_sumcheck_rows::CpuSumcheckBatchPlan::from_cpu(op)?); } "cpu.sumcheck_driver" => { - let symbol = string_attr(op, "sym_name")?; + let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?; steps.push(Stage7ProgramStepPlan { kind: "sumcheck_driver".to_owned(), - symbol: symbol.clone(), - }); - drivers.push(Stage7SumcheckDriverPlan { - symbol, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - kernel: Some(symbol_attr(op, "kernel")?), - relation: None, - batch: operand_symbol(op, 1)?, - policy: string_attr(op, "policy")?, - round_schedule: int_array_attr(op, "round_schedule")?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, + symbol: driver.symbol.clone(), }); + drivers.push(driver); } "cpu.sumcheck_verify" => { - let symbol = string_attr(op, "sym_name")?; + let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?; steps.push(Stage7ProgramStepPlan { kind: "sumcheck_driver".to_owned(), - symbol: symbol.clone(), - }); - drivers.push(Stage7SumcheckDriverPlan { - symbol, - stage: symbol_attr(op, "stage")?, - proof_slot: symbol_attr(op, "proof_slot")?, - kernel: None, - relation: Some(symbol_attr(op, "relation")?), - batch: operand_symbol(op, 1)?, - policy: string_attr(op, "policy")?, - round_schedule: int_array_attr(op, "round_schedule")?, - claim_label: string_attr(op, "claim_label")?, - round_label: string_attr(op, "round_label")?, - num_rounds: int_attr(op, "num_rounds")?, - degree: int_attr(op, "degree")?, + symbol: driver.symbol.clone(), }); + drivers.push(driver); } "cpu.sumcheck_instance_result" => { - instance_results.push(Stage7SumcheckInstanceResultPlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - claim: symbol_attr(op, "claim")?, - relation: symbol_attr(op, "relation")?, - index: int_attr(op, "index")?, - point_arity: int_attr(op, "point_arity")?, - num_rounds: int_attr(op, "num_rounds")?, - round_offset: int_attr(op, "round_offset")?, - point_order: string_attr(op, "point_order")?, - degree: int_attr(op, "degree")?, - }); + instance_results + .push(verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan::from_cpu(op)?); } "cpu.sumcheck_eval" => { - evals.push(Stage7SumcheckEvalPlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - name: symbol_attr(op, "name")?, - index: int_attr(op, "index")?, - oracle: symbol_attr(op, "oracle")?, - }); + evals.push(verifier_sumcheck_rows::CpuSumcheckEvalPlan::from_cpu(op)?); } "cpu.structured_polynomial_eval" => { relation_output_values.push( diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index 8f2ad3f320..e1a5115913 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -12,6 +12,7 @@ pub(crate) mod verifier_eval_families; pub(crate) mod verifier_opening_rows; pub(crate) mod verifier_plan; pub(crate) mod verifier_relation_outputs; +pub(crate) mod verifier_sumcheck_rows; pub(crate) mod verifier_values; pub use artifacts::{ diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index fdeabc7d36..330f5e67be 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -14,6 +14,10 @@ use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputEvalFamilyPlan, RelationOutputFunctionFamilyPlan, RelationOutputPlan, RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan, }; +use crate::protocols::jolt::verifier_sumcheck_rows::{ + CpuSumcheckBatchPlan, CpuSumcheckClaimPlan, CpuSumcheckDriverPlan, CpuSumcheckEvalPlan, + CpuSumcheckInstanceResultPlan, +}; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorSourceKind, VerifierFieldVectorSourceSet, VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarSourceKind, VerifierScalarSourceSet, @@ -554,11 +558,6 @@ pub(crate) trait VerifierStagePlanSource { type FieldConstant: VerifierFieldConstantSource; type FieldExpr: VerifierFieldExprSource; type ScalarExpr: VerifierScalarExprSource; - type Claim: VerifierSumcheckClaimSource; - type Batch: VerifierSumcheckBatchSource; - type Driver: VerifierSumcheckDriverSource; - type Instance: VerifierSumcheckInstanceResultSource; - type Eval: VerifierSumcheckEvalSource; type PointSlice: VerifierPointSliceSource; type PointConcat: VerifierPointConcatSource; @@ -569,11 +568,11 @@ pub(crate) trait VerifierStagePlanSource { fn field_constants(&self) -> &[Self::FieldConstant]; fn field_exprs(&self) -> &[Self::FieldExpr]; fn scalar_exprs(&self) -> &[Self::ScalarExpr]; - fn claims(&self) -> &[Self::Claim]; - fn batches(&self) -> &[Self::Batch]; - fn drivers(&self) -> &[Self::Driver]; - fn instance_results(&self) -> &[Self::Instance]; - fn sumcheck_evals(&self) -> &[Self::Eval]; + fn claims(&self) -> &[CpuSumcheckClaimPlan]; + fn batches(&self) -> &[CpuSumcheckBatchPlan]; + fn drivers(&self) -> &[CpuSumcheckDriverPlan]; + fn instance_results(&self) -> &[CpuSumcheckInstanceResultPlan]; + fn sumcheck_evals(&self) -> &[CpuSumcheckEvalPlan]; fn indexed_eval_families(&self) -> &[IndexedEvalFamilyPlan]; fn relation_output_values(&self) -> &[StructuredPolynomialEvalPlan]; fn relation_output_eval_families(&self) -> &[RelationOutputEvalFamilyPlan] { @@ -670,6 +669,188 @@ impl VerifierOpeningBatchSource for CpuOpeningBatchPlan { } } +impl VerifierSumcheckClaimSource for CpuSumcheckClaimPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn stage(&self) -> &str { + &self.stage + } + + fn domain(&self) -> &str { + &self.domain + } + + fn num_rounds(&self) -> usize { + self.num_rounds + } + + fn degree(&self) -> usize { + self.degree + } + + fn claim(&self) -> &str { + &self.claim + } + + fn relation(&self) -> Option<&str> { + self.relation.as_deref() + } + + fn claim_value(&self) -> &str { + &self.claim_value + } +} + +impl VerifierSumcheckBatchSource for CpuSumcheckBatchPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn stage(&self) -> &str { + &self.stage + } + + fn proof_slot(&self) -> &str { + &self.proof_slot + } + + fn policy(&self) -> &str { + &self.policy + } + + fn count(&self) -> usize { + self.count + } + + fn claim_operands(&self) -> &[String] { + &self.claim_operands + } + + fn claim_label(&self) -> &str { + &self.claim_label + } + + fn round_label(&self) -> &str { + &self.round_label + } + + fn round_schedule(&self) -> &[usize] { + &self.round_schedule + } +} + +impl VerifierSumcheckDriverSource for CpuSumcheckDriverPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn stage(&self) -> &str { + &self.stage + } + + fn proof_slot(&self) -> &str { + &self.proof_slot + } + + fn relation(&self) -> Option<&str> { + self.relation.as_deref() + } + + fn batch(&self) -> &str { + &self.batch + } + + fn policy(&self) -> &str { + &self.policy + } + + fn round_schedule(&self) -> &[usize] { + &self.round_schedule + } + + fn claim_label(&self) -> &str { + &self.claim_label + } + + fn round_label(&self) -> &str { + &self.round_label + } + + fn num_rounds(&self) -> usize { + self.num_rounds + } + + fn degree(&self) -> usize { + self.degree + } +} + +impl VerifierSumcheckInstanceResultSource for CpuSumcheckInstanceResultPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn source(&self) -> &str { + &self.source + } + + fn claim(&self) -> &str { + &self.claim + } + + fn relation(&self) -> &str { + &self.relation + } + + fn index(&self) -> usize { + self.index + } + + fn point_arity(&self) -> usize { + self.point_arity + } + + fn num_rounds(&self) -> usize { + self.num_rounds + } + + fn round_offset(&self) -> usize { + self.round_offset + } + + fn point_order(&self) -> &str { + &self.point_order + } + + fn degree(&self) -> usize { + self.degree + } +} + +impl VerifierSumcheckEvalSource for CpuSumcheckEvalPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn source(&self) -> &str { + &self.source + } + + fn name(&self) -> &str { + &self.name + } + + fn index(&self) -> usize { + self.index + } + + fn oracle(&self) -> &str { + &self.oracle + } +} + pub(crate) fn stage_plan_from_cpu_sources( source: &Source, ) -> Result @@ -967,11 +1148,6 @@ macro_rules! impl_verifier_plan_source_traits { field_constant = $field_constant:ty, field_expr = $field_expr:ty, scalar_expr = $scalar_expr:ty, - claim = $claim:ty, - batch = $batch:ty, - driver = $driver:ty, - instance = $instance:ty, - eval = $eval:ty, point_slice = $point_slice:ty, point_concat = $point_concat:ty $(, absorb = $absorb:ty)? @@ -989,11 +1165,6 @@ macro_rules! impl_verifier_plan_source_traits { type FieldConstant = $field_constant; type FieldExpr = $field_expr; type ScalarExpr = $scalar_expr; - type Claim = $claim; - type Batch = $batch; - type Driver = $driver; - type Instance = $instance; - type Eval = $eval; type PointSlice = $point_slice; type PointConcat = $point_concat; @@ -1008,11 +1179,11 @@ macro_rules! impl_verifier_plan_source_traits { fn field_constants(&self) -> &[Self::FieldConstant] { &self.field_constants } fn field_exprs(&self) -> &[Self::FieldExpr] { &self.field_exprs } fn scalar_exprs(&self) -> &[Self::ScalarExpr] { &self.scalar_exprs } - fn claims(&self) -> &[Self::Claim] { &self.claims } - fn batches(&self) -> &[Self::Batch] { &self.batches } - fn drivers(&self) -> &[Self::Driver] { &self.drivers } - fn instance_results(&self) -> &[Self::Instance] { &self.instance_results } - fn sumcheck_evals(&self) -> &[Self::Eval] { &self.evals } + fn claims(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckClaimPlan] { &self.claims } + fn batches(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckBatchPlan] { &self.batches } + fn drivers(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckDriverPlan] { &self.drivers } + fn instance_results(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan] { &self.instance_results } + fn sumcheck_evals(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckEvalPlan] { &self.evals } fn indexed_eval_families(&self) -> &[$crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan] { $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( @indexed_eval_families self $(, $indexed_eval_families)? @@ -1097,64 +1268,6 @@ macro_rules! impl_verifier_plan_source_traits { fn operands(&self) -> &[String] { &self.operands } } - impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckEvalSource for $eval { - fn symbol(&self) -> &str { &self.symbol } - fn source(&self) -> &str { &self.source } - fn name(&self) -> &str { &self.name } - fn index(&self) -> usize { self.index } - fn oracle(&self) -> &str { &self.oracle } - } - - impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckClaimSource for $claim { - fn symbol(&self) -> &str { &self.symbol } - fn stage(&self) -> &str { &self.stage } - fn domain(&self) -> &str { &self.domain } - fn num_rounds(&self) -> usize { self.num_rounds } - fn degree(&self) -> usize { self.degree } - fn claim(&self) -> &str { &self.claim } - fn relation(&self) -> Option<&str> { self.relation.as_deref() } - fn claim_value(&self) -> &str { &self.claim_value } - } - - impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckBatchSource for $batch { - fn symbol(&self) -> &str { &self.symbol } - fn stage(&self) -> &str { &self.stage } - fn proof_slot(&self) -> &str { &self.proof_slot } - fn policy(&self) -> &str { &self.policy } - fn count(&self) -> usize { self.count } - fn claim_operands(&self) -> &[String] { &self.claim_operands } - fn claim_label(&self) -> &str { &self.claim_label } - fn round_label(&self) -> &str { &self.round_label } - fn round_schedule(&self) -> &[usize] { &self.round_schedule } - } - - impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckDriverSource for $driver { - fn symbol(&self) -> &str { &self.symbol } - fn stage(&self) -> &str { &self.stage } - fn proof_slot(&self) -> &str { &self.proof_slot } - fn relation(&self) -> Option<&str> { self.relation.as_deref() } - fn batch(&self) -> &str { &self.batch } - fn policy(&self) -> &str { &self.policy } - fn round_schedule(&self) -> &[usize] { &self.round_schedule } - fn claim_label(&self) -> &str { &self.claim_label } - fn round_label(&self) -> &str { &self.round_label } - fn num_rounds(&self) -> usize { self.num_rounds } - fn degree(&self) -> usize { self.degree } - } - - impl $crate::protocols::jolt::verifier_plan::VerifierSumcheckInstanceResultSource for $instance { - fn symbol(&self) -> &str { &self.symbol } - fn source(&self) -> &str { &self.source } - fn claim(&self) -> &str { &self.claim } - fn relation(&self) -> &str { &self.relation } - fn index(&self) -> usize { self.index } - fn point_arity(&self) -> usize { self.point_arity } - fn num_rounds(&self) -> usize { self.num_rounds } - fn round_offset(&self) -> usize { self.round_offset } - fn point_order(&self) -> &str { &self.point_order } - fn degree(&self) -> usize { self.degree } - } - $( impl $crate::protocols::jolt::verifier_plan::VerifierPointZeroSource for $point_zero { fn symbol(&self) -> &str { &self.symbol } diff --git a/crates/bolt/src/protocols/jolt/verifier_sumcheck_rows.rs b/crates/bolt/src/protocols/jolt/verifier_sumcheck_rows.rs new file mode 100644 index 0000000000..491da60bb8 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_sumcheck_rows.rs @@ -0,0 +1,188 @@ +use melior::ir::OperationRef; + +use crate::emit::rust::EmitError; +use crate::protocols::jolt::cpu_attrs::{ + int_array_attr, int_attr, operand_symbol, operand_symbols, string_attr, symbol_array_attr, + symbol_attr, +}; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuSumcheckClaimPlan { + pub symbol: String, + pub stage: String, + pub domain: String, + pub num_rounds: usize, + pub degree: usize, + pub claim: String, + pub kernel: Option, + pub relation: Option, + pub claim_value: String, + pub input_openings: Vec, +} + +impl CpuSumcheckClaimPlan { + pub(crate) fn from_claim(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + stage: symbol_attr(operation, "stage")?, + domain: symbol_attr(operation, "domain")?, + num_rounds: int_attr(operation, "num_rounds")?, + degree: int_attr(operation, "degree")?, + claim: symbol_attr(operation, "claim")?, + kernel: Some(symbol_attr(operation, "kernel")?), + relation: None, + claim_value: operand_symbol(operation, 0)?, + input_openings: operand_symbols(operation, 1)?, + }) + } + + pub(crate) fn from_verify_claim(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + stage: symbol_attr(operation, "stage")?, + domain: symbol_attr(operation, "domain")?, + num_rounds: int_attr(operation, "num_rounds")?, + degree: int_attr(operation, "degree")?, + claim: symbol_attr(operation, "claim")?, + kernel: None, + relation: Some(symbol_attr(operation, "relation")?), + claim_value: operand_symbol(operation, 0)?, + input_openings: operand_symbols(operation, 1)?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuSumcheckBatchPlan { + pub symbol: String, + pub stage: String, + pub proof_slot: String, + pub policy: String, + pub count: usize, + pub ordered_claims: Vec, + pub claim_operands: Vec, + pub claim_label: String, + pub round_label: String, + pub round_schedule: Vec, +} + +impl CpuSumcheckBatchPlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + stage: symbol_attr(operation, "stage")?, + proof_slot: symbol_attr(operation, "proof_slot")?, + policy: string_attr(operation, "policy")?, + count: int_attr(operation, "count")?, + ordered_claims: symbol_array_attr(operation, "ordered_claims")?, + claim_operands: operand_symbols(operation, 0)?, + claim_label: string_attr(operation, "claim_label")?, + round_label: string_attr(operation, "round_label")?, + round_schedule: int_array_attr(operation, "round_schedule")?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuSumcheckDriverPlan { + pub symbol: String, + pub stage: String, + pub proof_slot: String, + pub kernel: Option, + pub relation: Option, + pub batch: String, + pub policy: String, + pub round_schedule: Vec, + pub claim_label: String, + pub round_label: String, + pub num_rounds: usize, + pub degree: usize, +} + +impl CpuSumcheckDriverPlan { + pub(crate) fn from_driver(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + stage: symbol_attr(operation, "stage")?, + proof_slot: symbol_attr(operation, "proof_slot")?, + kernel: Some(symbol_attr(operation, "kernel")?), + relation: None, + batch: operand_symbol(operation, 1)?, + policy: string_attr(operation, "policy")?, + round_schedule: int_array_attr(operation, "round_schedule")?, + claim_label: string_attr(operation, "claim_label")?, + round_label: string_attr(operation, "round_label")?, + num_rounds: int_attr(operation, "num_rounds")?, + degree: int_attr(operation, "degree")?, + }) + } + + pub(crate) fn from_verify(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + stage: symbol_attr(operation, "stage")?, + proof_slot: symbol_attr(operation, "proof_slot")?, + kernel: None, + relation: Some(symbol_attr(operation, "relation")?), + batch: operand_symbol(operation, 1)?, + policy: string_attr(operation, "policy")?, + round_schedule: int_array_attr(operation, "round_schedule")?, + claim_label: string_attr(operation, "claim_label")?, + round_label: string_attr(operation, "round_label")?, + num_rounds: int_attr(operation, "num_rounds")?, + degree: int_attr(operation, "degree")?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuSumcheckInstanceResultPlan { + pub symbol: String, + pub source: String, + pub claim: String, + pub relation: String, + pub index: usize, + pub point_arity: usize, + pub num_rounds: usize, + pub round_offset: usize, + pub point_order: String, + pub degree: usize, +} + +impl CpuSumcheckInstanceResultPlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + source: symbol_attr(operation, "source")?, + claim: symbol_attr(operation, "claim")?, + relation: symbol_attr(operation, "relation")?, + index: int_attr(operation, "index")?, + point_arity: int_attr(operation, "point_arity")?, + num_rounds: int_attr(operation, "num_rounds")?, + round_offset: int_attr(operation, "round_offset")?, + point_order: string_attr(operation, "point_order")?, + degree: int_attr(operation, "degree")?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuSumcheckEvalPlan { + pub symbol: String, + pub source: String, + pub name: String, + pub index: usize, + pub oracle: String, +} + +impl CpuSumcheckEvalPlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + source: symbol_attr(operation, "source")?, + name: symbol_attr(operation, "name")?, + index: int_attr(operation, "index")?, + oracle: symbol_attr(operation, "oracle")?, + }) + } +} From b9409ab79a2196f6c7709b723d1c0f4d0925c13b Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 02:45:46 -0600 Subject: [PATCH 127/171] refactor(bolt): share verifier value rows --- .../src/protocols/jolt/emit/rust/stage3.rs | 116 +++------------- .../src/protocols/jolt/emit/rust/stage4.rs | 97 +++----------- .../src/protocols/jolt/emit/rust/stage5.rs | 120 +++-------------- .../src/protocols/jolt/emit/rust/stage6.rs | 114 +++------------- .../src/protocols/jolt/emit/rust/stage7.rs | 124 ++++-------------- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../bolt/src/protocols/jolt/verifier_plan.rs | 84 +++++++----- .../src/protocols/jolt/verifier_value_rows.rs | 117 +++++++++++++++++ 8 files changed, 269 insertions(+), 504 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_value_rows.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 2056a3ce3a..f38a81866f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -6,18 +6,19 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_attr, operand_symbol, operand_symbols, operation_name, signed_int_attr, string_attr, - symbol_array_attr, symbol_attr, + int_attr, operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, + symbol_attr, }; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ - self, FieldExprDependencies, RelationOutputAst as Stage3RelationOutputAst, + self, RelationOutputAst as Stage3RelationOutputAst, RelationOutputFieldExprPlan as Stage3RelationOutputFieldExprPlan, RelationOutputPlan as Stage3RelationOutputPlan, StructuredPolynomialEvalPlan as Stage3StructuredPolynomialEvalPlan, }; use crate::protocols::jolt::verifier_sumcheck_rows; +use crate::protocols::jolt::verifier_value_rows; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -29,9 +30,9 @@ pub struct Stage3CpuProgram { pub steps: Vec, pub transcript_squeezes: Vec, pub opening_inputs: Vec, - pub field_constants: Vec, - pub field_exprs: Vec, - pub scalar_exprs: Vec, + pub field_constants: Vec, + pub field_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -88,49 +89,10 @@ pub struct Stage3OpeningInputPlan { pub claim_kind: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3FieldConstantPlan { - pub symbol: String, - pub field: String, - pub value: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3FieldExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3ScalarExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - -impl FieldExprDependencies for Stage3FieldExprPlan { - fn symbol(&self) -> &str { - &self.symbol - } - - fn operands(&self) -> &[String] { - &self.operands - } -} - -fn stage3_scalar_expr(expr: Stage3RelationOutputFieldExprPlan) -> Stage3ScalarExprPlan { - Stage3ScalarExprPlan { - symbol: expr.symbol, - kind: "op".to_owned(), - formula: expr.formula, - operand_names: expr.operands.clone(), - operands: expr.operands, - } +fn stage3_scalar_expr( + expr: Stage3RelationOutputFieldExprPlan, +) -> verifier_value_rows::CpuScalarExprPlan { + verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands) } #[derive(Clone, Debug, PartialEq, Eq)] @@ -155,9 +117,6 @@ verifier_plan::impl_verifier_plan_source_traits!( step = Stage3ProgramStepPlan, squeeze = Stage3TranscriptSqueezePlan, opening_input = Stage3OpeningInputPlan, - field_constant = Stage3FieldConstantPlan, - field_expr = Stage3FieldExprPlan, - scalar_expr = Stage3ScalarExprPlan, point_slice = Stage3PointSlicePlan, point_concat = Stage3PointConcatPlan, ); @@ -246,61 +205,24 @@ impl Stage3CpuProgram { }); } "cpu.field_const" => { - field_constants.push(Stage3FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: int_attr(op, "value")?, - }); + field_constants + .push(verifier_value_rows::CpuFieldConstantPlan::from_const(op)?); } "cpu.field_zero" => { - field_constants.push(Stage3FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: 0, - }); + field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_zero(op)?); } "cpu.field_one" => { - field_constants.push(Stage3FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: 1, - }); + field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_one(op)?); } "cpu.field_add" | "cpu.field_sub" | "cpu.field_mul" | "cpu.field_neg" => { - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage3FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: operation_name(op).replace("cpu.field_", "field."), - operand_names: operands.clone(), - operands, - }); + field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_op(op)?); } "cpu.field_pow" => { - let exponent = int_attr(op, "exponent")?; - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage3FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: format!("field.pow:{exponent}"), - operand_names: operands.clone(), - operands, - }); + field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_pow(op)?); } "cpu.poly_lagrange_basis_eval" => { - let domain_start = signed_int_attr(op, "domain_start")?; - let domain_size = int_attr(op, "domain_size")?; - let index = int_attr(op, "index")?; - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage3FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: format!( - "poly.lagrange_basis_eval:{domain_start}:{domain_size}:{index}" - ), - operand_names: operands.clone(), - operands, - }); + field_exprs + .push(verifier_value_rows::CpuFieldExprPlan::from_lagrange_basis_eval(op)?); } "cpu.sumcheck_claim" => { claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index c9c2cb0f9d..a195c7d93b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -17,12 +17,13 @@ use crate::protocols::jolt::cpu_attrs::{ use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ - self, FieldExprDependencies, RelationOutputAst as Stage4RelationOutputAst, + self, RelationOutputAst as Stage4RelationOutputAst, RelationOutputFieldExprPlan as Stage4RelationOutputFieldExprPlan, RelationOutputPlan as Stage4RelationOutputPlan, StructuredPolynomialEvalPlan as Stage4StructuredPolynomialEvalPlan, }; use crate::protocols::jolt::verifier_sumcheck_rows; +use crate::protocols::jolt::verifier_value_rows; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -35,9 +36,9 @@ pub struct Stage4CpuProgram { pub transcript_squeezes: Vec, pub transcript_absorb_bytes: Vec, pub opening_inputs: Vec, - pub field_constants: Vec, - pub field_exprs: Vec, - pub scalar_exprs: Vec, + pub field_constants: Vec, + pub field_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -101,49 +102,10 @@ pub struct Stage4OpeningInputPlan { pub claim_kind: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4FieldConstantPlan { - pub symbol: String, - pub field: String, - pub value: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4FieldExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4ScalarExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - -impl FieldExprDependencies for Stage4FieldExprPlan { - fn symbol(&self) -> &str { - &self.symbol - } - - fn operands(&self) -> &[String] { - &self.operands - } -} - -fn stage4_scalar_expr(expr: Stage4RelationOutputFieldExprPlan) -> Stage4ScalarExprPlan { - Stage4ScalarExprPlan { - symbol: expr.symbol, - kind: "op".to_owned(), - formula: expr.formula, - operand_names: expr.operands.clone(), - operands: expr.operands, - } +fn stage4_scalar_expr( + expr: Stage4RelationOutputFieldExprPlan, +) -> verifier_value_rows::CpuScalarExprPlan { + verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands) } #[derive(Clone, Debug, PartialEq, Eq)] @@ -168,9 +130,6 @@ verifier_plan::impl_verifier_plan_source_traits!( step = Stage4ProgramStepPlan, squeeze = Stage4TranscriptSqueezePlan, opening_input = Stage4OpeningInputPlan, - field_constant = Stage4FieldConstantPlan, - field_expr = Stage4FieldExprPlan, - scalar_expr = Stage4ScalarExprPlan, point_slice = Stage4PointSlicePlan, point_concat = Stage4PointConcatPlan, absorb = Stage4TranscriptAbsorbBytesPlan, @@ -273,46 +232,20 @@ impl Stage4CpuProgram { }); } "cpu.field_const" => { - field_constants.push(Stage4FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: int_attr(op, "value")?, - }); + field_constants + .push(verifier_value_rows::CpuFieldConstantPlan::from_const(op)?); } "cpu.field_zero" => { - field_constants.push(Stage4FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: 0, - }); + field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_zero(op)?); } "cpu.field_one" => { - field_constants.push(Stage4FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: 1, - }); + field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_one(op)?); } "cpu.field_add" | "cpu.field_sub" | "cpu.field_mul" | "cpu.field_neg" => { - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage4FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: operation_name(op).replace("cpu.field_", "field."), - operand_names: operands.clone(), - operands, - }); + field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_op(op)?); } "cpu.field_pow" => { - let exponent = int_attr(op, "exponent")?; - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage4FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: format!("field.pow:{exponent}"), - operand_names: operands.clone(), - operands, - }); + field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_pow(op)?); } "cpu.sumcheck_claim" => { claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 6be368e006..84cda5851a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -23,8 +23,7 @@ use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, - parse_output_product_family_plan, FieldExprDependencies, - RelationOutputAst as Stage5RelationOutputAst, + parse_output_product_family_plan, RelationOutputAst as Stage5RelationOutputAst, RelationOutputEvalFamilyPlan as Stage5RelationOutputEvalFamilyPlan, RelationOutputFieldExprPlan as Stage5RelationOutputFieldExprPlan, RelationOutputFunctionFamilyPlan as Stage5RelationOutputFunctionFamilyPlan, @@ -33,6 +32,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ StructuredPolynomialEvalPlan as Stage5StructuredPolynomialEvalPlan, }; use crate::protocols::jolt::verifier_sumcheck_rows; +use crate::protocols::jolt::verifier_value_rows; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -46,9 +46,9 @@ pub struct Stage5CpuProgram { pub transcript_squeezes: Vec, pub transcript_absorb_bytes: Vec, pub opening_inputs: Vec, - pub field_constants: Vec, - pub field_exprs: Vec, - pub scalar_exprs: Vec, + pub field_constants: Vec, + pub field_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -115,71 +115,22 @@ pub struct Stage5OpeningInputPlan { pub claim_kind: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5FieldConstantPlan { - pub symbol: String, - pub field: String, - pub value: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5FieldExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5ScalarExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, +fn stage5_field_expr( + expr: Stage5InstructionReadRafOutputFieldExprPlan, +) -> verifier_value_rows::CpuFieldExprPlan { + verifier_value_rows::CpuFieldExprPlan::op(expr.symbol, expr.formula, expr.operands) } -impl FieldExprDependencies for Stage5FieldExprPlan { - fn symbol(&self) -> &str { - &self.symbol - } - - fn operands(&self) -> &[String] { - &self.operands - } -} - -fn stage5_field_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage5FieldExprPlan { - Stage5FieldExprPlan { - symbol: expr.symbol, - kind: "op".to_owned(), - formula: expr.formula, - operand_names: expr.operands.clone(), - operands: expr.operands, - } -} - -fn stage5_scalar_expr(expr: Stage5InstructionReadRafOutputFieldExprPlan) -> Stage5ScalarExprPlan { - Stage5ScalarExprPlan { - symbol: expr.symbol, - kind: "op".to_owned(), - formula: expr.formula, - operand_names: expr.operands.clone(), - operands: expr.operands, - } +fn stage5_scalar_expr( + expr: Stage5InstructionReadRafOutputFieldExprPlan, +) -> verifier_value_rows::CpuScalarExprPlan { + verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands) } fn stage5_relation_output_scalar_expr( expr: Stage5RelationOutputFieldExprPlan, -) -> Stage5ScalarExprPlan { - Stage5ScalarExprPlan { - symbol: expr.symbol, - kind: "op".to_owned(), - formula: expr.formula, - operand_names: expr.operands.clone(), - operands: expr.operands, - } +) -> verifier_value_rows::CpuScalarExprPlan { + verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands) } #[derive(Clone, Debug, PartialEq, Eq)] @@ -204,9 +155,6 @@ verifier_plan::impl_verifier_plan_source_traits!( step = Stage5ProgramStepPlan, squeeze = Stage5TranscriptSqueezePlan, opening_input = Stage5OpeningInputPlan, - field_constant = Stage5FieldConstantPlan, - field_expr = Stage5FieldExprPlan, - scalar_expr = Stage5ScalarExprPlan, point_slice = Stage5PointSlicePlan, point_concat = Stage5PointConcatPlan, absorb = Stage5TranscriptAbsorbBytesPlan, @@ -317,46 +265,20 @@ impl Stage5CpuProgram { }); } "cpu.field_const" => { - field_constants.push(Stage5FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: int_attr(op, "value")?, - }); + field_constants + .push(verifier_value_rows::CpuFieldConstantPlan::from_const(op)?); } "cpu.field_zero" => { - field_constants.push(Stage5FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: 0, - }); + field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_zero(op)?); } "cpu.field_one" => { - field_constants.push(Stage5FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: 1, - }); + field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_one(op)?); } "cpu.field_add" | "cpu.field_sub" | "cpu.field_mul" | "cpu.field_neg" => { - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage5FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: operation_name(op).replace("cpu.field_", "field."), - operand_names: operands.clone(), - operands, - }); + field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_op(op)?); } "cpu.field_pow" => { - let exponent = int_attr(op, "exponent")?; - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage5FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: format!("field.pow:{exponent}"), - operand_names: operands.clone(), - operands, - }); + field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_pow(op)?); } "cpu.sumcheck_claim" => { claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index d014c4f831..c68de2f1ee 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -24,8 +24,7 @@ use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, - parse_output_product_family_plan, FieldExprDependencies, - RelationOutputAst as Stage6RelationOutputAst, + parse_output_product_family_plan, RelationOutputAst as Stage6RelationOutputAst, RelationOutputEvalFamilyPlan as Stage6RelationOutputEvalFamilyPlan, RelationOutputFieldExprPlan as Stage6RelationOutputFieldExprPlan, RelationOutputFunctionFamilyPlan as Stage6RelationOutputFunctionFamilyPlan, @@ -34,6 +33,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ StructuredPolynomialEvalPlan as Stage6StructuredPolynomialEvalPlan, }; use crate::protocols::jolt::verifier_sumcheck_rows; +use crate::protocols::jolt::verifier_value_rows; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -74,9 +74,9 @@ pub struct Stage6CpuProgram { pub transcript_squeezes: Vec, pub transcript_absorb_bytes: Vec, pub opening_inputs: Vec, - pub field_constants: Vec, - pub field_exprs: Vec, - pub scalar_exprs: Vec, + pub field_constants: Vec, + pub field_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -144,41 +144,6 @@ pub struct Stage6OpeningInputPlan { pub claim_kind: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6FieldConstantPlan { - pub symbol: String, - pub field: String, - pub value: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6FieldExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6ScalarExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - -impl FieldExprDependencies for Stage6FieldExprPlan { - fn symbol(&self) -> &str { - &self.symbol - } - - fn operands(&self) -> &[String] { - &self.operands - } -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage6PointZeroPlan { pub symbol: String, @@ -208,9 +173,6 @@ verifier_plan::impl_verifier_plan_source_traits!( step = Stage6ProgramStepPlan, squeeze = Stage6TranscriptSqueezePlan, opening_input = Stage6OpeningInputPlan, - field_constant = Stage6FieldConstantPlan, - field_expr = Stage6FieldExprPlan, - scalar_expr = Stage6ScalarExprPlan, point_slice = Stage6PointSlicePlan, point_concat = Stage6PointConcatPlan, absorb = Stage6TranscriptAbsorbBytesPlan, @@ -323,46 +285,20 @@ impl Stage6CpuProgram { }); } "cpu.field_const" => { - field_constants.push(Stage6FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: int_attr(op, "value")?, - }); + field_constants + .push(verifier_value_rows::CpuFieldConstantPlan::from_const(op)?); } "cpu.field_zero" => { - field_constants.push(Stage6FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: 0, - }); + field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_zero(op)?); } "cpu.field_one" => { - field_constants.push(Stage6FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: 1, - }); + field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_one(op)?); } "cpu.field_add" | "cpu.field_sub" | "cpu.field_mul" | "cpu.field_neg" => { - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage6FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: operation_name(op).replace("cpu.field_", "field."), - operand_names: operands.clone(), - operands, - }); + field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_op(op)?); } "cpu.field_pow" => { - let exponent = int_attr(op, "exponent")?; - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage6FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: format!("field.pow:{exponent}"), - operand_names: operands.clone(), - operands, - }); + field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_pow(op)?); } "cpu.sumcheck_claim" => { claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim( @@ -2577,7 +2513,7 @@ fn stage6_trace_rounds( } fn lower_stage6_relation_outputs( - field_exprs: &mut Vec, + field_exprs: &mut Vec, relation_output_eval_families: &mut Vec, relation_output_product_families: &mut Vec, relation_output_function_families: &mut Vec, @@ -2636,26 +2572,16 @@ fn lower_stage6_relation_outputs( Ok(()) } -fn stage6_relation_output_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage6FieldExprPlan { - let operands = expr.operands; - Stage6FieldExprPlan { - symbol: expr.symbol, - kind: "op".to_owned(), - formula: expr.formula, - operand_names: operands.clone(), - operands, - } +fn stage6_relation_output_expr( + expr: Stage6RelationOutputFieldExprPlan, +) -> verifier_value_rows::CpuFieldExprPlan { + verifier_value_rows::CpuFieldExprPlan::op(expr.symbol, expr.formula, expr.operands) } -fn stage6_scalar_expr(expr: Stage6RelationOutputFieldExprPlan) -> Stage6ScalarExprPlan { - let operands = expr.operands; - Stage6ScalarExprPlan { - symbol: expr.symbol, - kind: "op".to_owned(), - formula: expr.formula, - operand_names: operands.clone(), - operands, - } +fn stage6_scalar_expr( + expr: Stage6RelationOutputFieldExprPlan, +) -> verifier_value_rows::CpuScalarExprPlan { + verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands) } fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 8fd9f52749..c52d4c0ed7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -21,8 +21,7 @@ use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, - parse_output_product_family_plan, FieldExprDependencies, - RelationOutputAst as Stage7RelationOutputAst, + parse_output_product_family_plan, RelationOutputAst as Stage7RelationOutputAst, RelationOutputEvalFamilyPlan as Stage7RelationOutputEvalFamilyPlan, RelationOutputFieldExprPlan as Stage7RelationOutputFieldExprPlan, RelationOutputFunctionFamilyPlan as Stage7RelationOutputFunctionFamilyPlan, @@ -31,6 +30,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ StructuredPolynomialEvalPlan as Stage7StructuredPolynomialEvalPlan, }; use crate::protocols::jolt::verifier_sumcheck_rows; +use crate::protocols::jolt::verifier_value_rows; use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; @@ -56,9 +56,9 @@ pub struct Stage7CpuProgram { pub transcript_squeezes: Vec, pub transcript_absorb_bytes: Vec, pub opening_inputs: Vec, - pub field_constants: Vec, - pub field_exprs: Vec, - pub scalar_exprs: Vec, + pub field_constants: Vec, + pub field_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, @@ -126,59 +126,16 @@ pub struct Stage7OpeningInputPlan { pub claim_kind: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7FieldConstantPlan { - pub symbol: String, - pub field: String, - pub value: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7FieldExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7ScalarExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - -impl FieldExprDependencies for Stage7FieldExprPlan { - fn symbol(&self) -> &str { - &self.symbol - } - - fn operands(&self) -> &[String] { - &self.operands - } +fn stage7_relation_output_expr( + expr: Stage7RelationOutputFieldExprPlan, +) -> verifier_value_rows::CpuFieldExprPlan { + verifier_value_rows::CpuFieldExprPlan::op(expr.symbol, expr.formula, expr.operands) } -fn stage7_relation_output_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage7FieldExprPlan { - Stage7FieldExprPlan { - symbol: expr.symbol, - kind: "op".to_owned(), - formula: expr.formula, - operand_names: expr.operands.clone(), - operands: expr.operands, - } -} - -fn stage7_scalar_expr(expr: Stage7RelationOutputFieldExprPlan) -> Stage7ScalarExprPlan { - Stage7ScalarExprPlan { - symbol: expr.symbol, - kind: "op".to_owned(), - formula: expr.formula, - operand_names: expr.operands.clone(), - operands: expr.operands, - } +fn stage7_scalar_expr( + expr: Stage7RelationOutputFieldExprPlan, +) -> verifier_value_rows::CpuScalarExprPlan { + verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands) } struct HammingWeightClaimRow { @@ -188,8 +145,8 @@ struct HammingWeightClaimRow { } fn compact_hamming_weight_input_claim( - field_exprs: &mut Vec, - scalar_exprs: &mut Vec, + field_exprs: &mut Vec, + scalar_exprs: &mut Vec, claims: &mut [verifier_sumcheck_rows::CpuSumcheckClaimPlan], opening_inputs: &[Stage7OpeningInputPlan], ) -> Result<(), EmitError> { @@ -223,13 +180,11 @@ fn compact_hamming_weight_input_claim( operands.extend(rows.iter().map(|row| row.virtualization.clone())); field_exprs.retain(|expr| !is_hamming_weight_input_claim_expr(&expr.symbol)); - scalar_exprs.push(Stage7ScalarExprPlan { - symbol: compact_symbol.to_owned(), - kind: "op".to_owned(), - formula: power_strided_weighted_sum_formula(row_count, 3, &[], &[], &[0, 1, 2]), - operand_names: operands.clone(), + scalar_exprs.push(verifier_value_rows::CpuScalarExprPlan::op( + compact_symbol.to_owned(), + power_strided_weighted_sum_formula(row_count, 3, &[], &[], &[0, 1, 2]), operands, - }); + )); compact_symbol.clone_into(&mut claim.claim_value); Ok(()) } @@ -338,9 +293,6 @@ verifier_plan::impl_verifier_plan_source_traits!( step = Stage7ProgramStepPlan, squeeze = Stage7TranscriptSqueezePlan, opening_input = Stage7OpeningInputPlan, - field_constant = Stage7FieldConstantPlan, - field_expr = Stage7FieldExprPlan, - scalar_expr = Stage7ScalarExprPlan, point_slice = Stage7PointSlicePlan, point_concat = Stage7PointConcatPlan, absorb = Stage7TranscriptAbsorbBytesPlan, @@ -451,46 +403,20 @@ impl Stage7CpuProgram { }); } "cpu.field_const" => { - field_constants.push(Stage7FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: int_attr(op, "value")?, - }); + field_constants + .push(verifier_value_rows::CpuFieldConstantPlan::from_const(op)?); } "cpu.field_zero" => { - field_constants.push(Stage7FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: 0, - }); + field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_zero(op)?); } "cpu.field_one" => { - field_constants.push(Stage7FieldConstantPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - value: 1, - }); + field_constants.push(verifier_value_rows::CpuFieldConstantPlan::from_one(op)?); } "cpu.field_add" | "cpu.field_sub" | "cpu.field_mul" | "cpu.field_neg" => { - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage7FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: operation_name(op).replace("cpu.field_", "field."), - operand_names: operands.clone(), - operands, - }); + field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_op(op)?); } "cpu.field_pow" => { - let exponent = int_attr(op, "exponent")?; - let operands = operand_symbols(op, 0)?; - field_exprs.push(Stage7FieldExprPlan { - symbol: string_attr(op, "sym_name")?, - kind: "op".to_owned(), - formula: format!("field.pow:{exponent}"), - operand_names: operands.clone(), - operands, - }); + field_exprs.push(verifier_value_rows::CpuFieldExprPlan::from_field_pow(op)?); } "cpu.sumcheck_claim" => { claims.push(verifier_sumcheck_rows::CpuSumcheckClaimPlan::from_claim( diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index e1a5115913..f507cbd259 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -13,6 +13,7 @@ pub(crate) mod verifier_opening_rows; pub(crate) mod verifier_plan; pub(crate) mod verifier_relation_outputs; pub(crate) mod verifier_sumcheck_rows; +pub(crate) mod verifier_value_rows; pub(crate) mod verifier_values; pub use artifacts::{ diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 330f5e67be..ce40036566 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -18,6 +18,9 @@ use crate::protocols::jolt::verifier_sumcheck_rows::{ CpuSumcheckBatchPlan, CpuSumcheckClaimPlan, CpuSumcheckDriverPlan, CpuSumcheckEvalPlan, CpuSumcheckInstanceResultPlan, }; +use crate::protocols::jolt::verifier_value_rows::{ + CpuFieldConstantPlan, CpuFieldExprPlan, CpuScalarExprPlan, +}; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorSourceKind, VerifierFieldVectorSourceSet, VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarSourceKind, VerifierScalarSourceSet, @@ -555,9 +558,6 @@ pub(crate) trait VerifierStagePlanSource { type Step: VerifierProgramStepSource; type Squeeze: VerifierTranscriptSqueezeSource; type OpeningInput: VerifierOpeningInputSource; - type FieldConstant: VerifierFieldConstantSource; - type FieldExpr: VerifierFieldExprSource; - type ScalarExpr: VerifierScalarExprSource; type PointSlice: VerifierPointSliceSource; type PointConcat: VerifierPointConcatSource; @@ -565,9 +565,9 @@ pub(crate) trait VerifierStagePlanSource { fn transcript_squeezes(&self) -> &[Self::Squeeze]; fn transcript_absorb_bytes(&self) -> Vec; fn opening_inputs(&self) -> &[Self::OpeningInput]; - fn field_constants(&self) -> &[Self::FieldConstant]; - fn field_exprs(&self) -> &[Self::FieldExpr]; - fn scalar_exprs(&self) -> &[Self::ScalarExpr]; + fn field_constants(&self) -> &[CpuFieldConstantPlan]; + fn field_exprs(&self) -> &[CpuFieldExprPlan]; + fn scalar_exprs(&self) -> &[CpuScalarExprPlan]; fn claims(&self) -> &[CpuSumcheckClaimPlan]; fn batches(&self) -> &[CpuSumcheckBatchPlan]; fn drivers(&self) -> &[CpuSumcheckDriverPlan]; @@ -669,6 +669,48 @@ impl VerifierOpeningBatchSource for CpuOpeningBatchPlan { } } +impl VerifierFieldConstantSource for CpuFieldConstantPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn field(&self) -> &str { + &self.field + } + + fn value(&self) -> usize { + self.value + } +} + +impl VerifierFieldExprSource for CpuFieldExprPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn formula(&self) -> &str { + &self.formula + } + + fn operands(&self) -> &[String] { + &self.operands + } +} + +impl VerifierScalarExprSource for CpuScalarExprPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn formula(&self) -> &str { + &self.formula + } + + fn operands(&self) -> &[String] { + &self.operands + } +} + impl VerifierSumcheckClaimSource for CpuSumcheckClaimPlan { fn symbol(&self) -> &str { &self.symbol @@ -1145,9 +1187,6 @@ macro_rules! impl_verifier_plan_source_traits { step = $step:ty, squeeze = $squeeze:ty, opening_input = $opening_input:ty, - field_constant = $field_constant:ty, - field_expr = $field_expr:ty, - scalar_expr = $scalar_expr:ty, point_slice = $point_slice:ty, point_concat = $point_concat:ty $(, absorb = $absorb:ty)? @@ -1162,9 +1201,6 @@ macro_rules! impl_verifier_plan_source_traits { type Step = $step; type Squeeze = $squeeze; type OpeningInput = $opening_input; - type FieldConstant = $field_constant; - type FieldExpr = $field_expr; - type ScalarExpr = $scalar_expr; type PointSlice = $point_slice; type PointConcat = $point_concat; @@ -1176,9 +1212,9 @@ macro_rules! impl_verifier_plan_source_traits { ) } fn opening_inputs(&self) -> &[Self::OpeningInput] { &self.opening_inputs } - fn field_constants(&self) -> &[Self::FieldConstant] { &self.field_constants } - fn field_exprs(&self) -> &[Self::FieldExpr] { &self.field_exprs } - fn scalar_exprs(&self) -> &[Self::ScalarExpr] { &self.scalar_exprs } + fn field_constants(&self) -> &[$crate::protocols::jolt::verifier_value_rows::CpuFieldConstantPlan] { &self.field_constants } + fn field_exprs(&self) -> &[$crate::protocols::jolt::verifier_value_rows::CpuFieldExprPlan] { &self.field_exprs } + fn scalar_exprs(&self) -> &[$crate::protocols::jolt::verifier_value_rows::CpuScalarExprPlan] { &self.scalar_exprs } fn claims(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckClaimPlan] { &self.claims } fn batches(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckBatchPlan] { &self.batches } fn drivers(&self) -> &[$crate::protocols::jolt::verifier_sumcheck_rows::CpuSumcheckDriverPlan] { &self.drivers } @@ -1250,24 +1286,6 @@ macro_rules! impl_verifier_plan_source_traits { fn claim_kind(&self) -> &str { &self.claim_kind } } - impl $crate::protocols::jolt::verifier_plan::VerifierFieldConstantSource for $field_constant { - fn symbol(&self) -> &str { &self.symbol } - fn field(&self) -> &str { &self.field } - fn value(&self) -> usize { self.value } - } - - impl $crate::protocols::jolt::verifier_plan::VerifierFieldExprSource for $field_expr { - fn symbol(&self) -> &str { &self.symbol } - fn formula(&self) -> &str { &self.formula } - fn operands(&self) -> &[String] { &self.operands } - } - - impl $crate::protocols::jolt::verifier_plan::VerifierScalarExprSource for $scalar_expr { - fn symbol(&self) -> &str { &self.symbol } - fn formula(&self) -> &str { &self.formula } - fn operands(&self) -> &[String] { &self.operands } - } - $( impl $crate::protocols::jolt::verifier_plan::VerifierPointZeroSource for $point_zero { fn symbol(&self) -> &str { &self.symbol } diff --git a/crates/bolt/src/protocols/jolt/verifier_value_rows.rs b/crates/bolt/src/protocols/jolt/verifier_value_rows.rs new file mode 100644 index 0000000000..daf1ca3644 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_value_rows.rs @@ -0,0 +1,117 @@ +use melior::ir::OperationRef; + +use crate::emit::rust::EmitError; +use crate::protocols::jolt::cpu_attrs::{ + int_attr, operand_symbols, operation_name, signed_int_attr, string_attr, symbol_attr, +}; +use crate::protocols::jolt::verifier_relation_outputs::FieldExprDependencies; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuFieldConstantPlan { + pub symbol: String, + pub field: String, + pub value: usize, +} + +impl CpuFieldConstantPlan { + pub(crate) fn from_const(operation: OperationRef<'_, '_>) -> Result { + Self::from_value(operation, int_attr(operation, "value")?) + } + + pub(crate) fn from_zero(operation: OperationRef<'_, '_>) -> Result { + Self::from_value(operation, 0) + } + + pub(crate) fn from_one(operation: OperationRef<'_, '_>) -> Result { + Self::from_value(operation, 1) + } + + fn from_value(operation: OperationRef<'_, '_>, value: usize) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + field: symbol_attr(operation, "field")?, + value, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuFieldExprPlan { + pub symbol: String, + pub kind: String, + pub formula: String, + pub operand_names: Vec, + pub operands: Vec, +} + +impl CpuFieldExprPlan { + pub(crate) fn from_field_op(operation: OperationRef<'_, '_>) -> Result { + Ok(Self::op( + string_attr(operation, "sym_name")?, + operation_name(operation).replace("cpu.field_", "field."), + operand_symbols(operation, 0)?, + )) + } + + pub(crate) fn from_field_pow(operation: OperationRef<'_, '_>) -> Result { + Ok(Self::op( + string_attr(operation, "sym_name")?, + format!("field.pow:{}", int_attr(operation, "exponent")?), + operand_symbols(operation, 0)?, + )) + } + + pub(crate) fn from_lagrange_basis_eval( + operation: OperationRef<'_, '_>, + ) -> Result { + let domain_start = signed_int_attr(operation, "domain_start")?; + let domain_size = int_attr(operation, "domain_size")?; + let index = int_attr(operation, "index")?; + Ok(Self::op( + string_attr(operation, "sym_name")?, + format!("poly.lagrange_basis_eval:{domain_start}:{domain_size}:{index}"), + operand_symbols(operation, 0)?, + )) + } + + pub(crate) fn op(symbol: String, formula: String, operands: Vec) -> Self { + Self { + symbol, + kind: "op".to_owned(), + formula, + operand_names: operands.clone(), + operands, + } + } +} + +impl FieldExprDependencies for CpuFieldExprPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn operands(&self) -> &[String] { + &self.operands + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuScalarExprPlan { + pub symbol: String, + pub kind: String, + pub formula: String, + pub operand_names: Vec, + pub operands: Vec, +} + +impl CpuScalarExprPlan { + pub(crate) fn op(symbol: String, formula: String, operands: Vec) -> Self { + Self { + symbol, + kind: "op".to_owned(), + formula, + operand_names: operands.clone(), + operands, + } + } +} From 5bc1fbf3694ef772c07e9b1d06de55e5b7a23d69 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 02:53:37 -0600 Subject: [PATCH 128/171] refactor(bolt): share verifier point rows --- .../src/protocols/jolt/emit/rust/stage3.rs | 39 +------- .../src/protocols/jolt/emit/rust/stage4.rs | 39 +------- .../src/protocols/jolt/emit/rust/stage5.rs | 39 +------- .../src/protocols/jolt/emit/rust/stage6.rs | 56 ++--------- .../src/protocols/jolt/emit/rust/stage7.rs | 56 ++--------- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../bolt/src/protocols/jolt/verifier_plan.rs | 93 ++++++++++++------- .../src/protocols/jolt/verifier_point_rows.rs | 63 +++++++++++++ 8 files changed, 154 insertions(+), 232 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_point_rows.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index f38a81866f..2357503ba6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -11,6 +11,7 @@ use crate::protocols::jolt::cpu_attrs::{ }; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_point_rows; use crate::protocols::jolt::verifier_relation_outputs::{ self, RelationOutputAst as Stage3RelationOutputAst, RelationOutputFieldExprPlan as Stage3RelationOutputFieldExprPlan, @@ -41,8 +42,8 @@ pub struct Stage3CpuProgram { pub evals: Vec, pub relation_output_values: Vec, pub relation_outputs: Vec, - pub point_slices: Vec, - pub point_concats: Vec, + pub point_slices: Vec, + pub point_concats: Vec, pub opening_claims: Vec, pub opening_equalities: Vec, pub opening_batches: Vec, @@ -95,30 +96,11 @@ fn stage3_scalar_expr( verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands) } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3PointSlicePlan { - pub symbol: String, - pub source: String, - pub offset: usize, - pub length: usize, - pub input: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3PointConcatPlan { - pub symbol: String, - pub layout: String, - pub arity: usize, - pub inputs: Vec, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage3CpuProgram, step = Stage3ProgramStepPlan, squeeze = Stage3TranscriptSqueezePlan, opening_input = Stage3OpeningInputPlan, - point_slice = Stage3PointSlicePlan, - point_concat = Stage3PointConcatPlan, ); pub fn stage3_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -273,21 +255,10 @@ impl Stage3CpuProgram { }); } "cpu.point_slice" => { - point_slices.push(Stage3PointSlicePlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - offset: int_attr(op, "offset")?, - length: int_attr(op, "length")?, - input: operand_symbol(op, 0)?, - }); + point_slices.push(verifier_point_rows::CpuPointSlicePlan::from_cpu(op)?); } "cpu.point_concat" => { - point_concats.push(Stage3PointConcatPlan { - symbol: string_attr(op, "sym_name")?, - layout: string_attr(op, "layout")?, - arity: int_attr(op, "arity")?, - inputs: operand_symbols(op, 0)?, - }); + point_concats.push(verifier_point_rows::CpuPointConcatPlan::from_cpu(op)?); } "cpu.opening_claim" => { opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index a195c7d93b..322d4dbad8 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -16,6 +16,7 @@ use crate::protocols::jolt::cpu_attrs::{ }; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_point_rows; use crate::protocols::jolt::verifier_relation_outputs::{ self, RelationOutputAst as Stage4RelationOutputAst, RelationOutputFieldExprPlan as Stage4RelationOutputFieldExprPlan, @@ -47,8 +48,8 @@ pub struct Stage4CpuProgram { pub evals: Vec, pub relation_output_values: Vec, pub relation_outputs: Vec, - pub point_slices: Vec, - pub point_concats: Vec, + pub point_slices: Vec, + pub point_concats: Vec, pub opening_claims: Vec, pub opening_equalities: Vec, pub opening_batches: Vec, @@ -108,30 +109,11 @@ fn stage4_scalar_expr( verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands) } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4PointSlicePlan { - pub symbol: String, - pub source: String, - pub offset: usize, - pub length: usize, - pub input: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4PointConcatPlan { - pub symbol: String, - pub layout: String, - pub arity: usize, - pub inputs: Vec, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage4CpuProgram, step = Stage4ProgramStepPlan, squeeze = Stage4TranscriptSqueezePlan, opening_input = Stage4OpeningInputPlan, - point_slice = Stage4PointSlicePlan, - point_concat = Stage4PointConcatPlan, absorb = Stage4TranscriptAbsorbBytesPlan, ); @@ -296,21 +278,10 @@ impl Stage4CpuProgram { }); } "cpu.point_slice" => { - point_slices.push(Stage4PointSlicePlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - offset: int_attr(op, "offset")?, - length: int_attr(op, "length")?, - input: operand_symbol(op, 0)?, - }); + point_slices.push(verifier_point_rows::CpuPointSlicePlan::from_cpu(op)?); } "cpu.point_concat" => { - point_concats.push(Stage4PointConcatPlan { - symbol: string_attr(op, "sym_name")?, - layout: string_attr(op, "layout")?, - arity: int_attr(op, "arity")?, - inputs: operand_symbols(op, 0)?, - }); + point_concats.push(verifier_point_rows::CpuPointConcatPlan::from_cpu(op)?); } "cpu.opening_claim" => { opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 84cda5851a..0d3afa42b6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -21,6 +21,7 @@ use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_point_rows; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, RelationOutputAst as Stage5RelationOutputAst, @@ -60,8 +61,8 @@ pub struct Stage5CpuProgram { pub relation_output_product_families: Vec, pub relation_output_function_families: Vec, pub relation_outputs: Vec, - pub point_slices: Vec, - pub point_concats: Vec, + pub point_slices: Vec, + pub point_concats: Vec, pub opening_claims: Vec, pub opening_equalities: Vec, pub opening_batches: Vec, @@ -133,30 +134,11 @@ fn stage5_relation_output_scalar_expr( verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands) } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5PointSlicePlan { - pub symbol: String, - pub source: String, - pub offset: usize, - pub length: usize, - pub input: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5PointConcatPlan { - pub symbol: String, - pub layout: String, - pub arity: usize, - pub inputs: Vec, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage5CpuProgram, step = Stage5ProgramStepPlan, squeeze = Stage5TranscriptSqueezePlan, opening_input = Stage5OpeningInputPlan, - point_slice = Stage5PointSlicePlan, - point_concat = Stage5PointConcatPlan, absorb = Stage5TranscriptAbsorbBytesPlan, indexed_eval_families = indexed_eval_families, relation_output_eval_families = relation_output_eval_families, @@ -345,21 +327,10 @@ impl Stage5CpuProgram { }); } "cpu.point_slice" => { - point_slices.push(Stage5PointSlicePlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - offset: int_attr(op, "offset")?, - length: int_attr(op, "length")?, - input: operand_symbol(op, 0)?, - }); + point_slices.push(verifier_point_rows::CpuPointSlicePlan::from_cpu(op)?); } "cpu.point_concat" => { - point_concats.push(Stage5PointConcatPlan { - symbol: string_attr(op, "sym_name")?, - layout: string_attr(op, "layout")?, - arity: int_attr(op, "arity")?, - inputs: operand_symbols(op, 0)?, - }); + point_concats.push(verifier_point_rows::CpuPointConcatPlan::from_cpu(op)?); } "cpu.opening_claim" => { opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index c68de2f1ee..dc4d4d347e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -22,6 +22,7 @@ use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_point_rows; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, RelationOutputAst as Stage6RelationOutputAst, @@ -88,9 +89,9 @@ pub struct Stage6CpuProgram { pub relation_output_product_families: Vec, pub relation_output_function_families: Vec, pub relation_outputs: Vec, - pub point_zeros: Vec, - pub point_slices: Vec, - pub point_concats: Vec, + pub point_zeros: Vec, + pub point_slices: Vec, + pub point_concats: Vec, pub opening_claims: Vec, pub opening_equalities: Vec, pub opening_batches: Vec, @@ -144,39 +145,13 @@ pub struct Stage6OpeningInputPlan { pub claim_kind: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6PointZeroPlan { - pub symbol: String, - pub field: String, - pub arity: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6PointSlicePlan { - pub symbol: String, - pub source: String, - pub offset: usize, - pub length: usize, - pub input: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6PointConcatPlan { - pub symbol: String, - pub layout: String, - pub arity: usize, - pub inputs: Vec, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage6CpuProgram, step = Stage6ProgramStepPlan, squeeze = Stage6TranscriptSqueezePlan, opening_input = Stage6OpeningInputPlan, - point_slice = Stage6PointSlicePlan, - point_concat = Stage6PointConcatPlan, absorb = Stage6TranscriptAbsorbBytesPlan, - point_zero = Stage6PointZeroPlan, + point_zero = verifier_point_rows::CpuPointZeroPlan, indexed_eval_families = indexed_eval_families, relation_output_eval_families = relation_output_eval_families, relation_output_product_families = relation_output_product_families, @@ -365,28 +340,13 @@ impl Stage6CpuProgram { }); } "cpu.point_zero" => { - point_zeros.push(Stage6PointZeroPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - arity: int_attr(op, "arity")?, - }); + point_zeros.push(verifier_point_rows::CpuPointZeroPlan::from_cpu(op)?); } "cpu.point_slice" => { - point_slices.push(Stage6PointSlicePlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - offset: int_attr(op, "offset")?, - length: int_attr(op, "length")?, - input: operand_symbol(op, 0)?, - }); + point_slices.push(verifier_point_rows::CpuPointSlicePlan::from_cpu(op)?); } "cpu.point_concat" => { - point_concats.push(Stage6PointConcatPlan { - symbol: string_attr(op, "sym_name")?, - layout: string_attr(op, "layout")?, - arity: int_attr(op, "arity")?, - inputs: operand_symbols(op, 0)?, - }); + point_concats.push(verifier_point_rows::CpuPointConcatPlan::from_cpu(op)?); } "cpu.opening_claim" => { opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index c52d4c0ed7..e05a4a4734 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -19,6 +19,7 @@ use crate::protocols::jolt::rust_target_plan::{ }; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_point_rows; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, RelationOutputAst as Stage7RelationOutputAst, @@ -70,9 +71,9 @@ pub struct Stage7CpuProgram { pub relation_output_product_families: Vec, pub relation_output_function_families: Vec, pub relation_outputs: Vec, - pub point_zeros: Vec, - pub point_slices: Vec, - pub point_concats: Vec, + pub point_zeros: Vec, + pub point_slices: Vec, + pub point_concats: Vec, pub opening_claims: Vec, pub opening_equalities: Vec, pub opening_batches: Vec, @@ -264,39 +265,13 @@ fn is_hamming_weight_input_claim_expr(symbol: &str) -> bool { || symbol.starts_with("stage7.hamming_weight_claim_reduction.claim_expr") } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7PointZeroPlan { - pub symbol: String, - pub field: String, - pub arity: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7PointSlicePlan { - pub symbol: String, - pub source: String, - pub offset: usize, - pub length: usize, - pub input: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7PointConcatPlan { - pub symbol: String, - pub layout: String, - pub arity: usize, - pub inputs: Vec, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage7CpuProgram, step = Stage7ProgramStepPlan, squeeze = Stage7TranscriptSqueezePlan, opening_input = Stage7OpeningInputPlan, - point_slice = Stage7PointSlicePlan, - point_concat = Stage7PointConcatPlan, absorb = Stage7TranscriptAbsorbBytesPlan, - point_zero = Stage7PointZeroPlan, + point_zero = verifier_point_rows::CpuPointZeroPlan, relation_output_eval_families = relation_output_eval_families, relation_output_product_families = relation_output_product_families, relation_output_function_families = relation_output_function_families, @@ -479,28 +454,13 @@ impl Stage7CpuProgram { }); } "cpu.point_zero" => { - point_zeros.push(Stage7PointZeroPlan { - symbol: string_attr(op, "sym_name")?, - field: symbol_attr(op, "field")?, - arity: int_attr(op, "arity")?, - }); + point_zeros.push(verifier_point_rows::CpuPointZeroPlan::from_cpu(op)?); } "cpu.point_slice" => { - point_slices.push(Stage7PointSlicePlan { - symbol: string_attr(op, "sym_name")?, - source: symbol_attr(op, "source")?, - offset: int_attr(op, "offset")?, - length: int_attr(op, "length")?, - input: operand_symbol(op, 0)?, - }); + point_slices.push(verifier_point_rows::CpuPointSlicePlan::from_cpu(op)?); } "cpu.point_concat" => { - point_concats.push(Stage7PointConcatPlan { - symbol: string_attr(op, "sym_name")?, - layout: string_attr(op, "layout")?, - arity: int_attr(op, "arity")?, - inputs: operand_symbols(op, 0)?, - }); + point_concats.push(verifier_point_rows::CpuPointConcatPlan::from_cpu(op)?); } "cpu.opening_claim" => { opening_claims.push(verifier_opening_rows::CpuOpeningClaimPlan::from_cpu(op)?); diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index f507cbd259..f09948eba4 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -11,6 +11,7 @@ pub mod validate; pub(crate) mod verifier_eval_families; pub(crate) mod verifier_opening_rows; pub(crate) mod verifier_plan; +pub(crate) mod verifier_point_rows; pub(crate) mod verifier_relation_outputs; pub(crate) mod verifier_sumcheck_rows; pub(crate) mod verifier_value_rows; diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index ce40036566..65d91158d2 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -10,6 +10,9 @@ use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_opening_rows::{ CpuOpeningBatchPlan, CpuOpeningClaimEqualityPlan, CpuOpeningClaimPlan, }; +use crate::protocols::jolt::verifier_point_rows::{ + CpuPointConcatPlan, CpuPointSlicePlan, CpuPointZeroPlan, +}; use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputEvalFamilyPlan, RelationOutputFunctionFamilyPlan, RelationOutputPlan, RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan, @@ -558,8 +561,6 @@ pub(crate) trait VerifierStagePlanSource { type Step: VerifierProgramStepSource; type Squeeze: VerifierTranscriptSqueezeSource; type OpeningInput: VerifierOpeningInputSource; - type PointSlice: VerifierPointSliceSource; - type PointConcat: VerifierPointConcatSource; fn steps(&self) -> &[Self::Step]; fn transcript_squeezes(&self) -> &[Self::Squeeze]; @@ -711,6 +712,56 @@ impl VerifierScalarExprSource for CpuScalarExprPlan { } } +impl VerifierPointZeroSource for CpuPointZeroPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn field(&self) -> &str { + &self.field + } + + fn arity(&self) -> usize { + self.arity + } +} + +impl VerifierPointSliceSource for CpuPointSlicePlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn offset(&self) -> usize { + self.offset + } + + fn length(&self) -> usize { + self.length + } + + fn input(&self) -> &str { + &self.input + } +} + +impl VerifierPointConcatSource for CpuPointConcatPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn layout(&self) -> &str { + &self.layout + } + + fn arity(&self) -> usize { + self.arity + } + + fn inputs(&self) -> &[String] { + &self.inputs + } +} + impl VerifierSumcheckClaimSource for CpuSumcheckClaimPlan { fn symbol(&self) -> &str { &self.symbol @@ -1187,22 +1238,18 @@ macro_rules! impl_verifier_plan_source_traits { step = $step:ty, squeeze = $squeeze:ty, opening_input = $opening_input:ty, - point_slice = $point_slice:ty, - point_concat = $point_concat:ty - $(, absorb = $absorb:ty)? - $(, point_zero = $point_zero:ty)? - $(, indexed_eval_families = $indexed_eval_families:ident)? - $(, relation_output_eval_families = $relation_output_eval_families:ident)? - $(, relation_output_product_families = $relation_output_product_families:ident)? - $(, relation_output_function_families = $relation_output_function_families:ident)? + $(absorb = $absorb:ty,)? + $(point_zero = $point_zero:ty,)? + $(indexed_eval_families = $indexed_eval_families:ident,)? + $(relation_output_eval_families = $relation_output_eval_families:ident,)? + $(relation_output_product_families = $relation_output_product_families:ident,)? + $(relation_output_function_families = $relation_output_function_families:ident,)? $(,)? ) => { impl $crate::protocols::jolt::verifier_plan::VerifierStagePlanSource for $program { type Step = $step; type Squeeze = $squeeze; type OpeningInput = $opening_input; - type PointSlice = $point_slice; - type PointConcat = $point_concat; fn steps(&self) -> &[Self::Step] { &self.steps } fn transcript_squeezes(&self) -> &[Self::Squeeze] { &self.transcript_squeezes } @@ -1286,28 +1333,6 @@ macro_rules! impl_verifier_plan_source_traits { fn claim_kind(&self) -> &str { &self.claim_kind } } - $( - impl $crate::protocols::jolt::verifier_plan::VerifierPointZeroSource for $point_zero { - fn symbol(&self) -> &str { &self.symbol } - fn field(&self) -> &str { &self.field } - fn arity(&self) -> usize { self.arity } - } - )? - - impl $crate::protocols::jolt::verifier_plan::VerifierPointSliceSource for $point_slice { - fn symbol(&self) -> &str { &self.symbol } - fn offset(&self) -> usize { self.offset } - fn length(&self) -> usize { self.length } - fn input(&self) -> &str { &self.input } - } - - impl $crate::protocols::jolt::verifier_plan::VerifierPointConcatSource for $point_concat { - fn symbol(&self) -> &str { &self.symbol } - fn layout(&self) -> &str { &self.layout } - fn arity(&self) -> usize { self.arity } - fn inputs(&self) -> &[String] { &self.inputs } - } - }; (@transcript_absorb_bytes $self:ident, $absorb:ty) => { $crate::protocols::jolt::verifier_plan::transcript_absorb_bytes_from_cpu( diff --git a/crates/bolt/src/protocols/jolt/verifier_point_rows.rs b/crates/bolt/src/protocols/jolt/verifier_point_rows.rs new file mode 100644 index 0000000000..b53de28d64 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_point_rows.rs @@ -0,0 +1,63 @@ +use melior::ir::OperationRef; + +use crate::emit::rust::EmitError; +use crate::protocols::jolt::cpu_attrs::{ + int_attr, operand_symbol, operand_symbols, string_attr, symbol_attr, +}; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuPointZeroPlan { + pub symbol: String, + pub field: String, + pub arity: usize, +} + +impl CpuPointZeroPlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + field: symbol_attr(operation, "field")?, + arity: int_attr(operation, "arity")?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuPointSlicePlan { + pub symbol: String, + pub source: String, + pub offset: usize, + pub length: usize, + pub input: String, +} + +impl CpuPointSlicePlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + source: symbol_attr(operation, "source")?, + offset: int_attr(operation, "offset")?, + length: int_attr(operation, "length")?, + input: operand_symbol(operation, 0)?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuPointConcatPlan { + pub symbol: String, + pub layout: String, + pub arity: usize, + pub inputs: Vec, +} + +impl CpuPointConcatPlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + layout: string_attr(operation, "layout")?, + arity: int_attr(operation, "arity")?, + inputs: operand_symbols(operation, 0)?, + }) + } +} From 64a5630151610b6b905ffe54465e77b718dbbab8 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 03:05:39 -0600 Subject: [PATCH 129/171] refactor(bolt): share verifier program rows --- .../src/protocols/jolt/emit/rust/stage3.rs | 85 +++-------- .../src/protocols/jolt/emit/rust/stage4.rs | 108 ++++---------- .../src/protocols/jolt/emit/rust/stage5.rs | 108 ++++---------- .../src/protocols/jolt/emit/rust/stage6.rs | 108 ++++---------- .../src/protocols/jolt/emit/rust/stage7.rs | 112 ++++----------- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../bolt/src/protocols/jolt/verifier_plan.rs | 132 +++++++++++------- .../protocols/jolt/verifier_program_rows.rs | 80 +++++++++++ 8 files changed, 299 insertions(+), 435 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_program_rows.rs diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 2357503ba6..bea7ef77de 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -6,12 +6,12 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_attr, operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, - symbol_attr, + operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr, }; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_point_rows; +use crate::protocols::jolt::verifier_program_rows; use crate::protocols::jolt::verifier_relation_outputs::{ self, RelationOutputAst as Stage3RelationOutputAst, RelationOutputFieldExprPlan as Stage3RelationOutputFieldExprPlan, @@ -28,9 +28,9 @@ pub struct Stage3CpuProgram { pub role: Role, pub(crate) verifier_plan: Option, pub params: Stage3Params, - pub steps: Vec, - pub transcript_squeezes: Vec, - pub opening_inputs: Vec, + pub steps: Vec, + pub transcript_squeezes: Vec, + pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, pub scalar_exprs: Vec, @@ -65,43 +65,13 @@ pub struct Stage3KernelPlan { pub abi: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3TranscriptSqueezePlan { - pub symbol: String, - pub label: String, - pub kind: String, - pub count: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3ProgramStepPlan { - pub kind: String, - pub symbol: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage3OpeningInputPlan { - pub symbol: String, - pub source_stage: String, - pub source_claim: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, -} - fn stage3_scalar_expr( expr: Stage3RelationOutputFieldExprPlan, ) -> verifier_value_rows::CpuScalarExprPlan { verifier_value_rows::CpuScalarExprPlan::op(expr.symbol, expr.formula, expr.operands) } -verifier_plan::impl_verifier_plan_source_traits!( - program = Stage3CpuProgram, - step = Stage3ProgramStepPlan, - squeeze = Stage3TranscriptSqueezePlan, - opening_input = Stage3OpeningInputPlan, -); +verifier_plan::impl_verifier_plan_source_traits!(program = Stage3CpuProgram,); pub fn stage3_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { verify_cpu_schema(module)?; @@ -163,28 +133,15 @@ impl Stage3CpuProgram { }); } "cpu.transcript_squeeze" => { - let symbol = string_attr(op, "sym_name")?; - steps.push(Stage3ProgramStepPlan { - kind: "transcript_squeeze".to_owned(), - symbol: symbol.clone(), - }); - transcript_squeezes.push(Stage3TranscriptSqueezePlan { - symbol, - label: string_attr(op, "label")?, - kind: string_attr(op, "kind")?, - count: int_attr(op, "count")?, - }); + let squeeze = verifier_program_rows::CpuTranscriptSqueezePlan::from_cpu(op)?; + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "transcript_squeeze", + squeeze.symbol.clone(), + )); + transcript_squeezes.push(squeeze); } "cpu.opening_input" => { - opening_inputs.push(Stage3OpeningInputPlan { - symbol: string_attr(op, "sym_name")?, - source_stage: symbol_attr(op, "source_stage")?, - source_claim: symbol_attr(op, "source_claim")?, - oracle: symbol_attr(op, "oracle")?, - domain: symbol_attr(op, "domain")?, - point_arity: int_attr(op, "point_arity")?, - claim_kind: string_attr(op, "claim_kind")?, - }); + opening_inputs.push(verifier_program_rows::CpuOpeningInputPlan::from_cpu(op)?); } "cpu.field_const" => { field_constants @@ -220,18 +177,18 @@ impl Stage3CpuProgram { } "cpu.sumcheck_driver" => { let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?; - steps.push(Stage3ProgramStepPlan { - kind: "sumcheck_driver".to_owned(), - symbol: driver.symbol.clone(), - }); + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "sumcheck_driver", + driver.symbol.clone(), + )); drivers.push(driver); } "cpu.sumcheck_verify" => { let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?; - steps.push(Stage3ProgramStepPlan { - kind: "sumcheck_driver".to_owned(), - symbol: driver.symbol.clone(), - }); + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "sumcheck_driver", + driver.symbol.clone(), + )); drivers.push(driver); } "cpu.sumcheck_instance_result" => { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 322d4dbad8..d8079a125d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -11,12 +11,12 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_attr, operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, - symbol_attr, + operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr, }; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_point_rows; +use crate::protocols::jolt::verifier_program_rows; use crate::protocols::jolt::verifier_relation_outputs::{ self, RelationOutputAst as Stage4RelationOutputAst, RelationOutputFieldExprPlan as Stage4RelationOutputFieldExprPlan, @@ -33,10 +33,10 @@ pub struct Stage4CpuProgram { pub role: Role, pub(crate) verifier_plan: Option, pub params: Stage4Params, - pub steps: Vec, - pub transcript_squeezes: Vec, - pub transcript_absorb_bytes: Vec, - pub opening_inputs: Vec, + pub steps: Vec, + pub transcript_squeezes: Vec, + pub transcript_absorb_bytes: Vec, + pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, pub scalar_exprs: Vec, @@ -71,38 +71,6 @@ pub struct Stage4KernelPlan { pub abi: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4TranscriptSqueezePlan { - pub symbol: String, - pub label: String, - pub kind: String, - pub count: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4TranscriptAbsorbBytesPlan { - pub symbol: String, - pub label: String, - pub payload: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4ProgramStepPlan { - pub kind: String, - pub symbol: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage4OpeningInputPlan { - pub symbol: String, - pub source_stage: String, - pub source_claim: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, -} - fn stage4_scalar_expr( expr: Stage4RelationOutputFieldExprPlan, ) -> verifier_value_rows::CpuScalarExprPlan { @@ -111,10 +79,7 @@ fn stage4_scalar_expr( verifier_plan::impl_verifier_plan_source_traits!( program = Stage4CpuProgram, - step = Stage4ProgramStepPlan, - squeeze = Stage4TranscriptSqueezePlan, - opening_input = Stage4OpeningInputPlan, - absorb = Stage4TranscriptAbsorbBytesPlan, + absorb = transcript_absorb_bytes, ); pub fn stage4_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -178,40 +143,23 @@ impl Stage4CpuProgram { }); } "cpu.transcript_squeeze" => { - let symbol = string_attr(op, "sym_name")?; - steps.push(Stage4ProgramStepPlan { - kind: "transcript_squeeze".to_owned(), - symbol: symbol.clone(), - }); - transcript_squeezes.push(Stage4TranscriptSqueezePlan { - symbol, - label: string_attr(op, "label")?, - kind: string_attr(op, "kind")?, - count: int_attr(op, "count")?, - }); + let squeeze = verifier_program_rows::CpuTranscriptSqueezePlan::from_cpu(op)?; + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "transcript_squeeze", + squeeze.symbol.clone(), + )); + transcript_squeezes.push(squeeze); } "cpu.transcript_absorb_bytes" => { - let symbol = string_attr(op, "sym_name")?; - steps.push(Stage4ProgramStepPlan { - kind: "transcript_absorb_bytes".to_owned(), - symbol: symbol.clone(), - }); - transcript_absorb_bytes.push(Stage4TranscriptAbsorbBytesPlan { - symbol, - label: string_attr(op, "label")?, - payload: string_attr(op, "payload")?, - }); + let absorb = verifier_program_rows::CpuTranscriptAbsorbBytesPlan::from_cpu(op)?; + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "transcript_absorb_bytes", + absorb.symbol.clone(), + )); + transcript_absorb_bytes.push(absorb); } "cpu.opening_input" => { - opening_inputs.push(Stage4OpeningInputPlan { - symbol: string_attr(op, "sym_name")?, - source_stage: symbol_attr(op, "source_stage")?, - source_claim: symbol_attr(op, "source_claim")?, - oracle: symbol_attr(op, "oracle")?, - domain: symbol_attr(op, "domain")?, - point_arity: int_attr(op, "point_arity")?, - claim_kind: string_attr(op, "claim_kind")?, - }); + opening_inputs.push(verifier_program_rows::CpuOpeningInputPlan::from_cpu(op)?); } "cpu.field_const" => { field_constants @@ -243,18 +191,18 @@ impl Stage4CpuProgram { } "cpu.sumcheck_driver" => { let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?; - steps.push(Stage4ProgramStepPlan { - kind: "sumcheck_driver".to_owned(), - symbol: driver.symbol.clone(), - }); + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "sumcheck_driver", + driver.symbol.clone(), + )); drivers.push(driver); } "cpu.sumcheck_verify" => { let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?; - steps.push(Stage4ProgramStepPlan { - kind: "sumcheck_driver".to_owned(), - symbol: driver.symbol.clone(), - }); + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "sumcheck_driver", + driver.symbol.clone(), + )); drivers.push(driver); } "cpu.sumcheck_instance_result" => { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 0d3afa42b6..d543870114 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -11,8 +11,7 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_attr, operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, - symbol_attr, + operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr, }; use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ @@ -22,6 +21,7 @@ use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_point_rows; +use crate::protocols::jolt::verifier_program_rows; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, RelationOutputAst as Stage5RelationOutputAst, @@ -43,10 +43,10 @@ pub struct Stage5CpuProgram { pub(crate) verifier_plan: Option, pub(crate) indexed_eval_families: Vec, pub params: Stage5Params, - pub steps: Vec, - pub transcript_squeezes: Vec, - pub transcript_absorb_bytes: Vec, - pub opening_inputs: Vec, + pub steps: Vec, + pub transcript_squeezes: Vec, + pub transcript_absorb_bytes: Vec, + pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, pub scalar_exprs: Vec, @@ -84,38 +84,6 @@ pub struct Stage5KernelPlan { pub abi: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5TranscriptSqueezePlan { - pub symbol: String, - pub label: String, - pub kind: String, - pub count: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5TranscriptAbsorbBytesPlan { - pub symbol: String, - pub label: String, - pub payload: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5ProgramStepPlan { - pub kind: String, - pub symbol: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage5OpeningInputPlan { - pub symbol: String, - pub source_stage: String, - pub source_claim: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, -} - fn stage5_field_expr( expr: Stage5InstructionReadRafOutputFieldExprPlan, ) -> verifier_value_rows::CpuFieldExprPlan { @@ -136,10 +104,7 @@ fn stage5_relation_output_scalar_expr( verifier_plan::impl_verifier_plan_source_traits!( program = Stage5CpuProgram, - step = Stage5ProgramStepPlan, - squeeze = Stage5TranscriptSqueezePlan, - opening_input = Stage5OpeningInputPlan, - absorb = Stage5TranscriptAbsorbBytesPlan, + absorb = transcript_absorb_bytes, indexed_eval_families = indexed_eval_families, relation_output_eval_families = relation_output_eval_families, relation_output_product_families = relation_output_product_families, @@ -211,40 +176,23 @@ impl Stage5CpuProgram { }); } "cpu.transcript_squeeze" => { - let symbol = string_attr(op, "sym_name")?; - steps.push(Stage5ProgramStepPlan { - kind: "transcript_squeeze".to_owned(), - symbol: symbol.clone(), - }); - transcript_squeezes.push(Stage5TranscriptSqueezePlan { - symbol, - label: string_attr(op, "label")?, - kind: string_attr(op, "kind")?, - count: int_attr(op, "count")?, - }); + let squeeze = verifier_program_rows::CpuTranscriptSqueezePlan::from_cpu(op)?; + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "transcript_squeeze", + squeeze.symbol.clone(), + )); + transcript_squeezes.push(squeeze); } "cpu.transcript_absorb_bytes" => { - let symbol = string_attr(op, "sym_name")?; - steps.push(Stage5ProgramStepPlan { - kind: "transcript_absorb_bytes".to_owned(), - symbol: symbol.clone(), - }); - transcript_absorb_bytes.push(Stage5TranscriptAbsorbBytesPlan { - symbol, - label: string_attr(op, "label")?, - payload: string_attr(op, "payload")?, - }); + let absorb = verifier_program_rows::CpuTranscriptAbsorbBytesPlan::from_cpu(op)?; + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "transcript_absorb_bytes", + absorb.symbol.clone(), + )); + transcript_absorb_bytes.push(absorb); } "cpu.opening_input" => { - opening_inputs.push(Stage5OpeningInputPlan { - symbol: string_attr(op, "sym_name")?, - source_stage: symbol_attr(op, "source_stage")?, - source_claim: symbol_attr(op, "source_claim")?, - oracle: symbol_attr(op, "oracle")?, - domain: symbol_attr(op, "domain")?, - point_arity: int_attr(op, "point_arity")?, - claim_kind: string_attr(op, "claim_kind")?, - }); + opening_inputs.push(verifier_program_rows::CpuOpeningInputPlan::from_cpu(op)?); } "cpu.field_const" => { field_constants @@ -276,18 +224,18 @@ impl Stage5CpuProgram { } "cpu.sumcheck_driver" => { let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?; - steps.push(Stage5ProgramStepPlan { - kind: "sumcheck_driver".to_owned(), - symbol: driver.symbol.clone(), - }); + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "sumcheck_driver", + driver.symbol.clone(), + )); drivers.push(driver); } "cpu.sumcheck_verify" => { let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?; - steps.push(Stage5ProgramStepPlan { - kind: "sumcheck_driver".to_owned(), - symbol: driver.symbol.clone(), - }); + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "sumcheck_driver", + driver.symbol.clone(), + )); drivers.push(driver); } "cpu.sumcheck_instance_result" => { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index dc4d4d347e..29a4c33adf 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -11,8 +11,7 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_attr, operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, - symbol_attr, + operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr, }; use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ @@ -23,6 +22,7 @@ use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_point_rows; +use crate::protocols::jolt::verifier_program_rows; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, RelationOutputAst as Stage6RelationOutputAst, @@ -71,10 +71,10 @@ pub struct Stage6CpuProgram { pub(crate) verifier_plan: Option, pub(crate) indexed_eval_families: Vec, pub params: Stage6Params, - pub steps: Vec, - pub transcript_squeezes: Vec, - pub transcript_absorb_bytes: Vec, - pub opening_inputs: Vec, + pub steps: Vec, + pub transcript_squeezes: Vec, + pub transcript_absorb_bytes: Vec, + pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, pub scalar_exprs: Vec, @@ -113,44 +113,9 @@ pub struct Stage6KernelPlan { pub abi: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6TranscriptSqueezePlan { - pub symbol: String, - pub label: String, - pub kind: String, - pub count: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6TranscriptAbsorbBytesPlan { - pub symbol: String, - pub label: String, - pub payload: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6ProgramStepPlan { - pub kind: String, - pub symbol: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage6OpeningInputPlan { - pub symbol: String, - pub source_stage: String, - pub source_claim: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, -} - verifier_plan::impl_verifier_plan_source_traits!( program = Stage6CpuProgram, - step = Stage6ProgramStepPlan, - squeeze = Stage6TranscriptSqueezePlan, - opening_input = Stage6OpeningInputPlan, - absorb = Stage6TranscriptAbsorbBytesPlan, + absorb = transcript_absorb_bytes, point_zero = verifier_point_rows::CpuPointZeroPlan, indexed_eval_families = indexed_eval_families, relation_output_eval_families = relation_output_eval_families, @@ -224,40 +189,23 @@ impl Stage6CpuProgram { }); } "cpu.transcript_squeeze" => { - let symbol = string_attr(op, "sym_name")?; - steps.push(Stage6ProgramStepPlan { - kind: "transcript_squeeze".to_owned(), - symbol: symbol.clone(), - }); - transcript_squeezes.push(Stage6TranscriptSqueezePlan { - symbol, - label: string_attr(op, "label")?, - kind: string_attr(op, "kind")?, - count: int_attr(op, "count")?, - }); + let squeeze = verifier_program_rows::CpuTranscriptSqueezePlan::from_cpu(op)?; + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "transcript_squeeze", + squeeze.symbol.clone(), + )); + transcript_squeezes.push(squeeze); } "cpu.transcript_absorb_bytes" => { - let symbol = string_attr(op, "sym_name")?; - steps.push(Stage6ProgramStepPlan { - kind: "transcript_absorb_bytes".to_owned(), - symbol: symbol.clone(), - }); - transcript_absorb_bytes.push(Stage6TranscriptAbsorbBytesPlan { - symbol, - label: string_attr(op, "label")?, - payload: string_attr(op, "payload")?, - }); + let absorb = verifier_program_rows::CpuTranscriptAbsorbBytesPlan::from_cpu(op)?; + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "transcript_absorb_bytes", + absorb.symbol.clone(), + )); + transcript_absorb_bytes.push(absorb); } "cpu.opening_input" => { - opening_inputs.push(Stage6OpeningInputPlan { - symbol: string_attr(op, "sym_name")?, - source_stage: symbol_attr(op, "source_stage")?, - source_claim: symbol_attr(op, "source_claim")?, - oracle: symbol_attr(op, "oracle")?, - domain: symbol_attr(op, "domain")?, - point_arity: int_attr(op, "point_arity")?, - claim_kind: string_attr(op, "claim_kind")?, - }); + opening_inputs.push(verifier_program_rows::CpuOpeningInputPlan::from_cpu(op)?); } "cpu.field_const" => { field_constants @@ -289,18 +237,18 @@ impl Stage6CpuProgram { } "cpu.sumcheck_driver" => { let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?; - steps.push(Stage6ProgramStepPlan { - kind: "sumcheck_driver".to_owned(), - symbol: driver.symbol.clone(), - }); + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "sumcheck_driver", + driver.symbol.clone(), + )); drivers.push(driver); } "cpu.sumcheck_verify" => { let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?; - steps.push(Stage6ProgramStepPlan { - kind: "sumcheck_driver".to_owned(), - symbol: driver.symbol.clone(), - }); + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "sumcheck_driver", + driver.symbol.clone(), + )); drivers.push(driver); } "cpu.sumcheck_instance_result" => { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index e05a4a4734..4ccb710b21 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -11,8 +11,7 @@ use melior::ir::operation::OperationLike; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ - int_attr, operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, - symbol_attr, + operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr, }; use crate::protocols::jolt::rust_target_plan::{ power_strided_weighted_sum_formula, ScalarExprKind, @@ -20,6 +19,7 @@ use crate::protocols::jolt::rust_target_plan::{ use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; use crate::protocols::jolt::verifier_point_rows; +use crate::protocols::jolt::verifier_program_rows; use crate::protocols::jolt::verifier_relation_outputs::{ self, parse_output_eval_family_plan, parse_output_function_family_plan, parse_output_product_family_plan, RelationOutputAst as Stage7RelationOutputAst, @@ -53,10 +53,10 @@ pub struct Stage7CpuProgram { pub role: Role, pub(crate) verifier_plan: Option, pub params: Stage7Params, - pub steps: Vec, - pub transcript_squeezes: Vec, - pub transcript_absorb_bytes: Vec, - pub opening_inputs: Vec, + pub steps: Vec, + pub transcript_squeezes: Vec, + pub transcript_absorb_bytes: Vec, + pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, pub scalar_exprs: Vec, @@ -95,38 +95,6 @@ pub struct Stage7KernelPlan { pub abi: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7TranscriptSqueezePlan { - pub symbol: String, - pub label: String, - pub kind: String, - pub count: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7TranscriptAbsorbBytesPlan { - pub symbol: String, - pub label: String, - pub payload: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7ProgramStepPlan { - pub kind: String, - pub symbol: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage7OpeningInputPlan { - pub symbol: String, - pub source_stage: String, - pub source_claim: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, -} - fn stage7_relation_output_expr( expr: Stage7RelationOutputFieldExprPlan, ) -> verifier_value_rows::CpuFieldExprPlan { @@ -149,7 +117,7 @@ fn compact_hamming_weight_input_claim( field_exprs: &mut Vec, scalar_exprs: &mut Vec, claims: &mut [verifier_sumcheck_rows::CpuSumcheckClaimPlan], - opening_inputs: &[Stage7OpeningInputPlan], + opening_inputs: &[verifier_program_rows::CpuOpeningInputPlan], ) -> Result<(), EmitError> { let Some(claim) = claims .iter_mut() @@ -191,7 +159,7 @@ fn compact_hamming_weight_input_claim( } fn hamming_weight_claim_rows( - opening_inputs: &[Stage7OpeningInputPlan], + opening_inputs: &[verifier_program_rows::CpuOpeningInputPlan], ) -> Result, EmitError> { const HAMMING_INPUT: &str = "stage7.input.stage6.hamming_booleanity.HammingWeight"; const BOOLEANITY_PREFIX: &str = "stage7.input.stage6.booleanity."; @@ -267,10 +235,7 @@ fn is_hamming_weight_input_claim_expr(symbol: &str) -> bool { verifier_plan::impl_verifier_plan_source_traits!( program = Stage7CpuProgram, - step = Stage7ProgramStepPlan, - squeeze = Stage7TranscriptSqueezePlan, - opening_input = Stage7OpeningInputPlan, - absorb = Stage7TranscriptAbsorbBytesPlan, + absorb = transcript_absorb_bytes, point_zero = verifier_point_rows::CpuPointZeroPlan, relation_output_eval_families = relation_output_eval_families, relation_output_product_families = relation_output_product_families, @@ -342,40 +307,23 @@ impl Stage7CpuProgram { }); } "cpu.transcript_squeeze" => { - let symbol = string_attr(op, "sym_name")?; - steps.push(Stage7ProgramStepPlan { - kind: "transcript_squeeze".to_owned(), - symbol: symbol.clone(), - }); - transcript_squeezes.push(Stage7TranscriptSqueezePlan { - symbol, - label: string_attr(op, "label")?, - kind: string_attr(op, "kind")?, - count: int_attr(op, "count")?, - }); + let squeeze = verifier_program_rows::CpuTranscriptSqueezePlan::from_cpu(op)?; + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "transcript_squeeze", + squeeze.symbol.clone(), + )); + transcript_squeezes.push(squeeze); } "cpu.transcript_absorb_bytes" => { - let symbol = string_attr(op, "sym_name")?; - steps.push(Stage7ProgramStepPlan { - kind: "transcript_absorb_bytes".to_owned(), - symbol: symbol.clone(), - }); - transcript_absorb_bytes.push(Stage7TranscriptAbsorbBytesPlan { - symbol, - label: string_attr(op, "label")?, - payload: string_attr(op, "payload")?, - }); + let absorb = verifier_program_rows::CpuTranscriptAbsorbBytesPlan::from_cpu(op)?; + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "transcript_absorb_bytes", + absorb.symbol.clone(), + )); + transcript_absorb_bytes.push(absorb); } "cpu.opening_input" => { - opening_inputs.push(Stage7OpeningInputPlan { - symbol: string_attr(op, "sym_name")?, - source_stage: symbol_attr(op, "source_stage")?, - source_claim: symbol_attr(op, "source_claim")?, - oracle: symbol_attr(op, "oracle")?, - domain: symbol_attr(op, "domain")?, - point_arity: int_attr(op, "point_arity")?, - claim_kind: string_attr(op, "claim_kind")?, - }); + opening_inputs.push(verifier_program_rows::CpuOpeningInputPlan::from_cpu(op)?); } "cpu.field_const" => { field_constants @@ -407,18 +355,18 @@ impl Stage7CpuProgram { } "cpu.sumcheck_driver" => { let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_driver(op)?; - steps.push(Stage7ProgramStepPlan { - kind: "sumcheck_driver".to_owned(), - symbol: driver.symbol.clone(), - }); + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "sumcheck_driver", + driver.symbol.clone(), + )); drivers.push(driver); } "cpu.sumcheck_verify" => { let driver = verifier_sumcheck_rows::CpuSumcheckDriverPlan::from_verify(op)?; - steps.push(Stage7ProgramStepPlan { - kind: "sumcheck_driver".to_owned(), - symbol: driver.symbol.clone(), - }); + steps.push(verifier_program_rows::CpuProgramStepPlan::new( + "sumcheck_driver", + driver.symbol.clone(), + )); drivers.push(driver); } "cpu.sumcheck_instance_result" => { diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index f09948eba4..da4161aa4a 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -12,6 +12,7 @@ pub(crate) mod verifier_eval_families; pub(crate) mod verifier_opening_rows; pub(crate) mod verifier_plan; pub(crate) mod verifier_point_rows; +pub(crate) mod verifier_program_rows; pub(crate) mod verifier_relation_outputs; pub(crate) mod verifier_sumcheck_rows; pub(crate) mod verifier_value_rows; diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 65d91158d2..50380061d4 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -13,6 +13,9 @@ use crate::protocols::jolt::verifier_opening_rows::{ use crate::protocols::jolt::verifier_point_rows::{ CpuPointConcatPlan, CpuPointSlicePlan, CpuPointZeroPlan, }; +use crate::protocols::jolt::verifier_program_rows::{ + CpuOpeningInputPlan, CpuProgramStepPlan, CpuTranscriptAbsorbBytesPlan, CpuTranscriptSqueezePlan, +}; use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputEvalFamilyPlan, RelationOutputFunctionFamilyPlan, RelationOutputPlan, RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan, @@ -558,14 +561,10 @@ pub(crate) trait VerifierOpeningBatchSource { } pub(crate) trait VerifierStagePlanSource { - type Step: VerifierProgramStepSource; - type Squeeze: VerifierTranscriptSqueezeSource; - type OpeningInput: VerifierOpeningInputSource; - - fn steps(&self) -> &[Self::Step]; - fn transcript_squeezes(&self) -> &[Self::Squeeze]; + fn steps(&self) -> &[CpuProgramStepPlan]; + fn transcript_squeezes(&self) -> &[CpuTranscriptSqueezePlan]; fn transcript_absorb_bytes(&self) -> Vec; - fn opening_inputs(&self) -> &[Self::OpeningInput]; + fn opening_inputs(&self) -> &[CpuOpeningInputPlan]; fn field_constants(&self) -> &[CpuFieldConstantPlan]; fn field_exprs(&self) -> &[CpuFieldExprPlan]; fn scalar_exprs(&self) -> &[CpuScalarExprPlan]; @@ -670,6 +669,78 @@ impl VerifierOpeningBatchSource for CpuOpeningBatchPlan { } } +impl VerifierProgramStepSource for CpuProgramStepPlan { + fn kind(&self) -> &str { + &self.kind + } + + fn symbol(&self) -> &str { + &self.symbol + } +} + +impl VerifierTranscriptSqueezeSource for CpuTranscriptSqueezePlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn label(&self) -> &str { + &self.label + } + + fn kind(&self) -> &str { + &self.kind + } + + fn count(&self) -> usize { + self.count + } +} + +impl VerifierTranscriptAbsorbBytesSource for CpuTranscriptAbsorbBytesPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn label(&self) -> &str { + &self.label + } + + fn payload(&self) -> &str { + &self.payload + } +} + +impl VerifierOpeningInputSource for CpuOpeningInputPlan { + fn symbol(&self) -> &str { + &self.symbol + } + + fn source_stage(&self) -> &str { + &self.source_stage + } + + fn source_claim(&self) -> &str { + &self.source_claim + } + + fn oracle(&self) -> &str { + &self.oracle + } + + fn domain(&self) -> &str { + &self.domain + } + + fn point_arity(&self) -> usize { + self.point_arity + } + + fn claim_kind(&self) -> &str { + &self.claim_kind + } +} + impl VerifierFieldConstantSource for CpuFieldConstantPlan { fn symbol(&self) -> &str { &self.symbol @@ -1235,10 +1306,7 @@ where macro_rules! impl_verifier_plan_source_traits { ( program = $program:ty, - step = $step:ty, - squeeze = $squeeze:ty, - opening_input = $opening_input:ty, - $(absorb = $absorb:ty,)? + $(absorb = $absorb:ident,)? $(point_zero = $point_zero:ty,)? $(indexed_eval_families = $indexed_eval_families:ident,)? $(relation_output_eval_families = $relation_output_eval_families:ident,)? @@ -1247,18 +1315,14 @@ macro_rules! impl_verifier_plan_source_traits { $(,)? ) => { impl $crate::protocols::jolt::verifier_plan::VerifierStagePlanSource for $program { - type Step = $step; - type Squeeze = $squeeze; - type OpeningInput = $opening_input; - - fn steps(&self) -> &[Self::Step] { &self.steps } - fn transcript_squeezes(&self) -> &[Self::Squeeze] { &self.transcript_squeezes } + fn steps(&self) -> &[$crate::protocols::jolt::verifier_program_rows::CpuProgramStepPlan] { &self.steps } + fn transcript_squeezes(&self) -> &[$crate::protocols::jolt::verifier_program_rows::CpuTranscriptSqueezePlan] { &self.transcript_squeezes } fn transcript_absorb_bytes(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierTranscriptAbsorbBytesPlan> { $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( @transcript_absorb_bytes self $(, $absorb)? ) } - fn opening_inputs(&self) -> &[Self::OpeningInput] { &self.opening_inputs } + fn opening_inputs(&self) -> &[$crate::protocols::jolt::verifier_program_rows::CpuOpeningInputPlan] { &self.opening_inputs } fn field_constants(&self) -> &[$crate::protocols::jolt::verifier_value_rows::CpuFieldConstantPlan] { &self.field_constants } fn field_exprs(&self) -> &[$crate::protocols::jolt::verifier_value_rows::CpuFieldExprPlan] { &self.field_exprs } fn scalar_exprs(&self) -> &[$crate::protocols::jolt::verifier_value_rows::CpuScalarExprPlan] { &self.scalar_exprs } @@ -1303,38 +1367,8 @@ macro_rules! impl_verifier_plan_source_traits { fn opening_batches(&self) -> &[$crate::protocols::jolt::verifier_opening_rows::CpuOpeningBatchPlan] { &self.opening_batches } } - impl $crate::protocols::jolt::verifier_plan::VerifierProgramStepSource for $step { - fn kind(&self) -> &str { &self.kind } - fn symbol(&self) -> &str { &self.symbol } - } - - impl $crate::protocols::jolt::verifier_plan::VerifierTranscriptSqueezeSource for $squeeze { - fn symbol(&self) -> &str { &self.symbol } - fn label(&self) -> &str { &self.label } - fn kind(&self) -> &str { &self.kind } - fn count(&self) -> usize { self.count } - } - - $( - impl $crate::protocols::jolt::verifier_plan::VerifierTranscriptAbsorbBytesSource for $absorb { - fn symbol(&self) -> &str { &self.symbol } - fn label(&self) -> &str { &self.label } - fn payload(&self) -> &str { &self.payload } - } - )? - - impl $crate::protocols::jolt::verifier_plan::VerifierOpeningInputSource for $opening_input { - fn symbol(&self) -> &str { &self.symbol } - fn source_stage(&self) -> &str { &self.source_stage } - fn source_claim(&self) -> &str { &self.source_claim } - fn oracle(&self) -> &str { &self.oracle } - fn domain(&self) -> &str { &self.domain } - fn point_arity(&self) -> usize { self.point_arity } - fn claim_kind(&self) -> &str { &self.claim_kind } - } - }; - (@transcript_absorb_bytes $self:ident, $absorb:ty) => { + (@transcript_absorb_bytes $self:ident, $absorb:ident) => { $crate::protocols::jolt::verifier_plan::transcript_absorb_bytes_from_cpu( &$self.transcript_absorb_bytes, ) diff --git a/crates/bolt/src/protocols/jolt/verifier_program_rows.rs b/crates/bolt/src/protocols/jolt/verifier_program_rows.rs new file mode 100644 index 0000000000..f5fd950ffa --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_program_rows.rs @@ -0,0 +1,80 @@ +use melior::ir::OperationRef; + +use crate::emit::rust::EmitError; +use crate::protocols::jolt::cpu_attrs::{int_attr, string_attr, symbol_attr}; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuProgramStepPlan { + pub kind: String, + pub symbol: String, +} + +impl CpuProgramStepPlan { + pub(crate) fn new(kind: &str, symbol: String) -> Self { + Self { + kind: kind.to_owned(), + symbol, + } + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuTranscriptSqueezePlan { + pub symbol: String, + pub label: String, + pub kind: String, + pub count: usize, +} + +impl CpuTranscriptSqueezePlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + label: string_attr(operation, "label")?, + kind: string_attr(operation, "kind")?, + count: int_attr(operation, "count")?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuTranscriptAbsorbBytesPlan { + pub symbol: String, + pub label: String, + pub payload: String, +} + +impl CpuTranscriptAbsorbBytesPlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + label: string_attr(operation, "label")?, + payload: string_attr(operation, "payload")?, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CpuOpeningInputPlan { + pub symbol: String, + pub source_stage: String, + pub source_claim: String, + pub oracle: String, + pub domain: String, + pub point_arity: usize, + pub claim_kind: String, +} + +impl CpuOpeningInputPlan { + pub(crate) fn from_cpu(operation: OperationRef<'_, '_>) -> Result { + Ok(Self { + symbol: string_attr(operation, "sym_name")?, + source_stage: symbol_attr(operation, "source_stage")?, + source_claim: symbol_attr(operation, "source_claim")?, + oracle: symbol_attr(operation, "oracle")?, + domain: symbol_attr(operation, "domain")?, + point_arity: int_attr(operation, "point_arity")?, + claim_kind: string_attr(operation, "claim_kind")?, + }) + } +} From 55dec83cea78ddb85828e15b125ebface675176a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 03:10:43 -0600 Subject: [PATCH 130/171] test(bolt): track verifier value graph metrics --- .../jolt/verifier_jolt_relations.rs.template | 20 ------- crates/bolt/tests/verifier_cleanup.rs | 55 ++++++++++++++++++- .../src/stages/jolt_relations.rs | 20 ------- 3 files changed, 54 insertions(+), 41 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index ac949a04dc..f95a8d1c76 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -304,26 +304,6 @@ pub fn evaluate_stage67_bytecode_read_raf_output_scalars, local_point: &[Fr], log_t: usize, -) -> Result>, RuntimePlanError> { - stage67_bytecode_read_raf_output_terms( - plan, - entries, - entry_bytecode_index, - num_lookup_tables, - store, - local_point, - log_t, - ) -} - -fn stage67_bytecode_read_raf_output_terms( - plan: &Stage67BytecodeReadRafPlan, - entries: &[E], - entry_bytecode_index: usize, - num_lookup_tables: usize, - store: &ValueStore, - local_point: &[Fr], - log_t: usize, ) -> Result>, RuntimePlanError> { let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, plan.point)?; let log_k = opening_point.len() - log_t; diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 01f4202ee8..42066bc0d0 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -38,6 +38,7 @@ const STAGE_HELPER_FUNCTION_BASELINE_CEILING: usize = 38; const RELATION_STRING_SITE_BASELINE_CEILING: usize = 0; const SUMCHECK_POINT_ORDER_STRING_SITE_BASELINE_CEILING: usize = 0; const RELATION_INDEXED_EVAL_PREFIX_SITE_BASELINE_CEILING: usize = 0; +const HANDWRITTEN_EXPECTED_OUTPUT_FUNCTION_BASELINE_CEILING: usize = 12; const ALLOWED_JOLT_PROTOCOL_SYMBOLS: &[&str] = &[ "jolt.commitment_phase", @@ -145,6 +146,10 @@ struct VerifierCleanupMetrics { relation_string_sites: usize, sumcheck_point_order_string_sites: usize, relation_indexed_eval_prefix_sites: usize, + compute_poly_op_call_sites: usize, + compute_point_op_call_sites: usize, + value_graph_relation_outputs: usize, + handwritten_expected_output_functions: usize, } #[test] @@ -172,7 +177,11 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { stage_local_helper_functions: {helper_functions} (baseline ceiling <= {helper_baseline})\n\ relation_string_sites: {relation_sites} (baseline ceiling <= {relation_baseline})\n\ sumcheck_point_order_string_sites: {point_order_sites} (baseline ceiling <= {point_order_baseline})\n\ - relation_indexed_eval_prefix_sites: {indexed_eval_prefix_sites} (baseline ceiling <= {indexed_eval_prefix_baseline})", + relation_indexed_eval_prefix_sites: {indexed_eval_prefix_sites} (baseline ceiling <= {indexed_eval_prefix_baseline})\n\ + compute_poly_op_call_sites: {compute_poly_op_call_sites}\n\ + compute_point_op_call_sites: {compute_point_op_call_sites}\n\ + value_graph_relation_outputs: {value_graph_relation_outputs}\n\ + handwritten_expected_output_functions: {expected_output_functions} (baseline ceiling <= {expected_output_functions_baseline})", generated_surface_loc = metrics.generated_surface_loc, bolt_runtime_loc = metrics.bolt_runtime_loc, bolt_runtime_baseline = BOLT_RUNTIME_BASELINE_LOC_CEILING, @@ -209,6 +218,12 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { point_order_baseline = SUMCHECK_POINT_ORDER_STRING_SITE_BASELINE_CEILING, indexed_eval_prefix_sites = metrics.relation_indexed_eval_prefix_sites, indexed_eval_prefix_baseline = RELATION_INDEXED_EVAL_PREFIX_SITE_BASELINE_CEILING, + compute_poly_op_call_sites = metrics.compute_poly_op_call_sites, + compute_point_op_call_sites = metrics.compute_point_op_call_sites, + value_graph_relation_outputs = metrics.value_graph_relation_outputs, + expected_output_functions = metrics.handwritten_expected_output_functions, + expected_output_functions_baseline = + HANDWRITTEN_EXPECTED_OUTPUT_FUNCTION_BASELINE_CEILING, ); assert!( @@ -304,6 +319,12 @@ fn checked_in_generated_verifier_metrics_are_recorded_and_bounded() { "relation indexed-eval prefix sites grew to {}; prefer typed eval-family plan data", metrics.relation_indexed_eval_prefix_sites ); + assert!( + metrics.handwritten_expected_output_functions + <= HANDWRITTEN_EXPECTED_OUTPUT_FUNCTION_BASELINE_CEILING, + "handwritten expected-output helper count grew to {}; move output math into typed value-graph plan data", + metrics.handwritten_expected_output_functions + ); } #[test] @@ -660,6 +681,11 @@ fn verifier_cleanup_metrics(verifier_src: &Path) -> VerifierCleanupMetrics { count_sumcheck_point_order_string_sites(&source); metrics.relation_indexed_eval_prefix_sites += count_relation_indexed_eval_prefix_sites(&source); + metrics.compute_poly_op_call_sites += count_compute_poly_op_call_sites(&source); + metrics.compute_point_op_call_sites += count_compute_point_op_call_sites(&source); + metrics.value_graph_relation_outputs += count_value_graph_relation_outputs(&source); + metrics.handwritten_expected_output_functions += + count_handwritten_expected_output_functions(&source); } } metrics @@ -778,6 +804,33 @@ fn count_relation_indexed_eval_prefix_sites(source: &str) -> usize { .count() } +fn count_compute_poly_op_call_sites(source: &str) -> usize { + source + .matches("ScalarExprKind::StructuredPolynomial") + .count() +} + +fn count_compute_point_op_call_sites(source: &str) -> usize { + source + .lines() + .filter(|line| line.contains("PointExprKind::") && line.contains("PointExprPlan")) + .count() +} + +fn count_value_graph_relation_outputs(source: &str) -> usize { + source + .lines() + .filter(|line| line.contains("RelationOutputPlan {") && line.contains("expected_output:")) + .count() +} + +fn count_handwritten_expected_output_functions(source: &str) -> usize { + source + .lines() + .filter(|line| line.trim_start().starts_with("fn expected_")) + .count() +} + fn assert_allowed_jolt_protocol_symbol(path: &Path, symbol: &str) { assert!( ALLOWED_JOLT_PROTOCOL_SYMBOLS.contains(&symbol), diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index ac949a04dc..f95a8d1c76 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -304,26 +304,6 @@ pub fn evaluate_stage67_bytecode_read_raf_output_scalars, local_point: &[Fr], log_t: usize, -) -> Result>, RuntimePlanError> { - stage67_bytecode_read_raf_output_terms( - plan, - entries, - entry_bytecode_index, - num_lookup_tables, - store, - local_point, - log_t, - ) -} - -fn stage67_bytecode_read_raf_output_terms( - plan: &Stage67BytecodeReadRafPlan, - entries: &[E], - entry_bytecode_index: usize, - num_lookup_tables: usize, - store: &ValueStore, - local_point: &[Fr], - log_t: usize, ) -> Result>, RuntimePlanError> { let opening_point = normalize_bytecode_read_raf_point(local_point, log_t, plan.point)?; let log_k = opening_point.len() - log_t; From a8adce239130c60d690552085b010221ab27a07a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 03:23:26 -0600 Subject: [PATCH 131/171] refactor(bolt): share batched relation outputs --- crates/bolt-verifier-runtime/src/lib.rs | 47 +++++++++++++ .../src/protocols/jolt/emit/rust/stage3.rs | 56 ++++------------ .../src/protocols/jolt/emit/rust/stage4.rs | 56 ++++------------ .../src/protocols/jolt/emit/rust/stage7.rs | 67 ++++--------------- crates/bolt/tests/commitment_ir.rs | 2 +- crates/jolt-verifier/src/stages/stage3.rs | 56 ++++------------ crates/jolt-verifier/src/stages/stage4.rs | 56 ++++------------ crates/jolt-verifier/src/stages/stage7.rs | 67 ++++--------------- 8 files changed, 132 insertions(+), 275 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 8d9693bceb..86665bb77b 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -1345,6 +1345,53 @@ pub fn evaluate_relation_output_for_instance( ) } +pub fn expected_relation_output_batch( + driver: &SumcheckDriverPlan, + batches: &[SumcheckBatchPlan], + claims: &[SumcheckClaimPlan], + instance_results: &[SumcheckInstanceResultPlan], + relation_outputs: &[RelationOutputPlan], + field_exprs: &[FieldExprPlan], + scalar_exprs: &[ScalarExprPlan], + store: &ValueStore, + evals: &[StageNamedEval], + point: &[Fr], + batching_coeffs: &[Fr], +) -> Result { + let batch = find_batch(batches, driver.symbol, driver.batch)?; + let claims = batch_claims(claims, batch)?; + let mut expected = Fr::from_u64(0); + for (claim, coefficient) in claims.iter().zip(batching_coeffs) { + let instance = instance_results + .iter() + .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) + .ok_or(RuntimePlanError::MissingClaim { + batch: batch.symbol, + claim: claim.symbol, + })?; + let local_point = point + .get(instance.round_offset..instance.round_offset + instance.num_rounds) + .ok_or(RuntimePlanError::InvalidInputLength { + input: instance.symbol, + expected: instance.round_offset + instance.num_rounds, + actual: point.len(), + })?; + let value = evaluate_relation_output_for_instance( + relation_outputs, + field_exprs, + scalar_exprs, + store, + instance, + evals, + &[], + &[], + local_point, + )?; + expected += *coefficient * value; + } + Ok(expected) +} + fn relation_output_x_point_source<'a>( source: &'static str, instance_symbol: &'static str, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index bea7ef77de..3681b09b67 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -815,7 +815,7 @@ impl Stage3CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ + "use bolt_verifier_runtime::find_plan;\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, Transcript};" @@ -1776,7 +1776,19 @@ where store, transcript, |store, evals, point, batching_coeffs| { - expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs) + Ok(bolt_verifier_runtime::expected_relation_output_batch( + driver, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + store, + evals, + point, + batching_coeffs, + )?) }, |store, verified| observe_stage3_sumcheck_output(program, store, verified), |driver, error| VerifyStage3Error::Sumcheck { driver, error }, @@ -1830,46 +1842,6 @@ fn observe_stage3_sumcheck_output( ) } -fn expected_batched_output_claim( - program: &'static Stage3VerifierProgramPlan, - driver: &'static Stage3SumcheckDriverPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage3NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage3Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage3Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, &[], &[], local_point, - )?; - expected += *coefficient * value; - } - Ok(expected) -} - "# } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index d8079a125d..6b21145962 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -826,7 +826,7 @@ impl Stage4CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ + "use bolt_verifier_runtime::find_plan;\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -2027,7 +2027,19 @@ where store, transcript, |store, evals, point, batching_coeffs| { - expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs) + Ok(bolt_verifier_runtime::expected_relation_output_batch( + driver, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + store, + evals, + point, + batching_coeffs, + )?) }, |store, verified| observe_stage4_sumcheck_output(program, store, verified), |driver, error| VerifyStage4Error::Sumcheck { driver, error }, @@ -2084,46 +2096,6 @@ fn observe_stage4_sumcheck_output( ) } -fn expected_batched_output_claim( - program: &'static Stage4VerifierProgramPlan, - driver: &'static Stage4SumcheckDriverPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage4NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage4Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage4Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, &[], &[], local_point, - )?; - expected += *coefficient * value; - } - Ok(expected) -} - fn normalize_stage4_registers_rw_point( program: &'static Stage4VerifierProgramPlan, driver: &'static str, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 4ccb710b21..7bc12bc5dc 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1046,7 +1046,7 @@ impl Stage7CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ + "use bolt_verifier_runtime::find_plan;\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -2253,7 +2253,19 @@ where store, transcript, |store, evals, point, batching_coeffs| { - expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs) + Ok(bolt_verifier_runtime::expected_relation_output_batch( + driver, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + store, + evals, + point, + batching_coeffs, + )?) }, |store, verified| observe_stage7_sumcheck_output(program, store, verified), |driver, error| VerifyStage7Error::Sumcheck { driver, error }, @@ -2306,57 +2318,6 @@ fn observe_stage7_sumcheck_output( |symbol| VerifyStage7Error::MissingValue { symbol }, ) } - -fn expected_batched_output_claim( - program: &'static Stage7VerifierProgramPlan, - driver: &'static Stage7SumcheckDriverPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage7NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage7Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage7Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let Some(relation) = claim.relation else { - return Err(VerifyStage7Error::InvalidProof { - driver: driver.symbol, - reason: "missing claim relation", - }); - }; - let value = match relation { - Stage7RelationKind::Stage7HammingWeightClaimReduction => { - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, &[], &[], local_point, - )? - } - relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }), - }; - expected += *coefficient * value; - } - Ok(expected) -} "# } } diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 2430052146..69b3e37239 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -2173,7 +2173,7 @@ fn stage7_rust_targets_extract_and_compile() { .contains("stage7.hamming_weight_claim_reduction.output.term")); assert!(verifier_source .source - .contains("bolt_verifier_runtime::evaluate_relation_output_for_instance")); + .contains("bolt_verifier_runtime::expected_relation_output_batch")); assert!(verifier_source .source .contains("stage7.input.stage6.booleanity.InstructionRa_0")); diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 9c5165e788..7665d860cf 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; +use bolt_verifier_runtime::find_plan; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, Transcript}; @@ -391,7 +391,19 @@ where store, transcript, |store, evals, point, batching_coeffs| { - expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs) + Ok(bolt_verifier_runtime::expected_relation_output_batch( + driver, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + store, + evals, + point, + batching_coeffs, + )?) }, |store, verified| observe_stage3_sumcheck_output(program, store, verified), |driver, error| VerifyStage3Error::Sumcheck { driver, error }, @@ -444,43 +456,3 @@ fn observe_stage3_sumcheck_output( |symbol| VerifyStage3Error::MissingValue { symbol }, ) } - -fn expected_batched_output_claim( - program: &'static Stage3VerifierProgramPlan, - driver: &'static Stage3SumcheckDriverPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage3NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage3Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage3Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, &[], &[], local_point, - )?; - expected += *coefficient * value; - } - Ok(expected) -} diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index c795fb3f35..87d15df945 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; +use bolt_verifier_runtime::find_plan; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -369,7 +369,19 @@ where store, transcript, |store, evals, point, batching_coeffs| { - expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs) + Ok(bolt_verifier_runtime::expected_relation_output_batch( + driver, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + store, + evals, + point, + batching_coeffs, + )?) }, |store, verified| observe_stage4_sumcheck_output(program, store, verified), |driver, error| VerifyStage4Error::Sumcheck { driver, error }, @@ -426,46 +438,6 @@ fn observe_stage4_sumcheck_output( ) } -fn expected_batched_output_claim( - program: &'static Stage4VerifierProgramPlan, - driver: &'static Stage4SumcheckDriverPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage4NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage4Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage4Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let value = bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, &[], &[], local_point, - )?; - expected += *coefficient * value; - } - Ok(expected) -} - fn normalize_stage4_registers_rw_point( program: &'static Stage4VerifierProgramPlan, driver: &'static str, diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 8845603fa0..20aea04f37 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; +use bolt_verifier_runtime::find_plan; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -473,7 +473,19 @@ where store, transcript, |store, evals, point, batching_coeffs| { - expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs) + Ok(bolt_verifier_runtime::expected_relation_output_batch( + driver, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + store, + evals, + point, + batching_coeffs, + )?) }, |store, verified| observe_stage7_sumcheck_output(program, store, verified), |driver, error| VerifyStage7Error::Sumcheck { driver, error }, @@ -526,54 +538,3 @@ fn observe_stage7_sumcheck_output( |symbol| VerifyStage7Error::MissingValue { symbol }, ) } - -fn expected_batched_output_claim( - program: &'static Stage7VerifierProgramPlan, - driver: &'static Stage7SumcheckDriverPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage7NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage7Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage7Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let Some(relation) = claim.relation else { - return Err(VerifyStage7Error::InvalidProof { - driver: driver.symbol, - reason: "missing claim relation", - }); - }; - let value = match relation { - Stage7RelationKind::Stage7HammingWeightClaimReduction => { - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, &[], &[], local_point, - )? - } - relation => return Err(VerifyStage7Error::UnsupportedRelation { relation }), - }; - expected += *coefficient * value; - } - Ok(expected) -} From baafe53c1d125e9933dff3b9fd23198d0b524db0 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 03:38:07 -0600 Subject: [PATCH 132/171] refactor(bolt): type stage2 ram output --- crates/bolt-verifier-runtime/src/lib.rs | 19 -- .../src/protocols/jolt/emit/rust/stage2.rs | 300 +++++++++++++++--- crates/jolt-verifier/src/stages/stage2.rs | 64 ++-- 3 files changed, 279 insertions(+), 104 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 86665bb77b..5479cdb26e 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -514,25 +514,6 @@ pub struct StageVerifierProgramPlan { pub opening_batches: &'static [OpeningBatchPlan], } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct StageVerifierProgramPlanNoEqualities { - pub params: StageParams, - pub steps: &'static [ProgramStepPlan], - pub transcript_squeezes: &'static [TranscriptSqueezePlan], - pub opening_inputs: &'static [OpeningInputPlan], - pub field_constants: &'static [FieldConstantPlan], - pub field_exprs: &'static [FieldExprPlan], - pub scalar_exprs: &'static [ScalarExprPlan], - pub claims: &'static [SumcheckClaimPlan], - pub batches: &'static [SumcheckBatchPlan], - pub drivers: &'static [SumcheckDriverPlan], - pub instance_results: &'static [SumcheckInstanceResultPlan], - pub evals: &'static [SumcheckEvalPlan], - pub point_exprs: &'static [PointExprPlan], - pub opening_claims: &'static [OpeningClaimPlan], - pub opening_batches: &'static [OpeningBatchPlan], -} - #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct VerifierProgramPlanMinimal { pub params: StageParams, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 74eac6cbe1..7b91808262 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -7,12 +7,14 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::rust_target_plan::{ - ClaimKind, FieldExprKind, JoltVerifierRelationKind, ProgramStepKind, RustTargetPlanError, - TranscriptSqueezeKind, + structured_polynomial_scalar_formula, ClaimKind, FieldExprKind, JoltVerifierRelationKind, + ProgramStepKind, RustTargetPlanError, ScalarExprKind, TranscriptSqueezeKind, }; -use crate::protocols::jolt::verifier_plan; +use crate::protocols::jolt::{verifier_plan, verifier_relation_outputs, verifier_values}; use crate::schema::verify_cpu_schema; +type Stage2RelationOutputPlan = verifier_relation_outputs::RelationOutputPlan; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage2CpuProgram { pub role: Role, @@ -22,12 +24,14 @@ pub struct Stage2CpuProgram { pub opening_inputs: Vec, pub field_constants: Vec, pub field_exprs: Vec, + pub scalar_exprs: Vec, pub kernels: Vec, pub claims: Vec, pub batches: Vec, pub drivers: Vec, pub instance_results: Vec, pub evals: Vec, + pub relation_outputs: Vec, pub point_slices: Vec, pub point_concats: Vec, pub opening_claims: Vec, @@ -91,6 +95,107 @@ pub struct Stage2FieldExprPlan { pub operands: Vec, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Stage2ScalarExprPlan { + pub symbol: String, + pub kind: String, + pub formula: String, + pub operand_names: Vec, + pub operands: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct Stage2RelationOutputRows { + field_exprs: Vec, + scalar_exprs: Vec, + relation_outputs: Vec, +} + +fn stage2_field_expr( + symbol: &str, + formula: &str, + operands: impl IntoIterator, +) -> Stage2FieldExprPlan { + let operands = operands.into_iter().map(str::to_owned).collect::>(); + Stage2FieldExprPlan { + symbol: symbol.to_owned(), + kind: "op".to_owned(), + formula: formula.to_owned(), + operand_names: operands.clone(), + operands, + } +} + +fn stage2_scalar_expr( + symbol: &str, + formula: String, + operands: impl IntoIterator, +) -> Stage2ScalarExprPlan { + let operands = operands.into_iter().map(str::to_owned).collect::>(); + Stage2ScalarExprPlan { + symbol: symbol.to_owned(), + kind: "op".to_owned(), + formula, + operand_names: operands.clone(), + operands, + } +} + +fn stage2_ram_read_write_relation_output_plans() -> Stage2RelationOutputRows { + Stage2RelationOutputRows { + scalar_exprs: vec![stage2_scalar_expr( + "stage2.ram_read_write.output.eq.Cycle", + structured_polynomial_scalar_formula( + "eq", "prefix", "y_point", "reverse", "full", "full", "as_is", + ), + [ + "stage2.ram_read_write.instance", + "stage2.input.stage1.RamReadValue", + ], + )], + field_exprs: vec![ + stage2_field_expr( + "stage2.ram_read_write.output.partial.ValPlusInc", + "field.add", + [ + "stage2.ram_read_write.eval.RamVal", + "stage2.ram_read_write.eval.RamInc", + ], + ), + stage2_field_expr( + "stage2.ram_read_write.output.term.GammaValPlusInc", + "field.mul", + [ + "stage2.ram_read_write.gamma", + "stage2.ram_read_write.output.partial.ValPlusInc", + ], + ), + stage2_field_expr( + "stage2.ram_read_write.output.partial.WeightedVal", + "field.add", + [ + "stage2.ram_read_write.eval.RamVal", + "stage2.ram_read_write.output.term.GammaValPlusInc", + ], + ), + stage2_field_expr( + "stage2.ram_read_write.output.claim_expr", + "field.product", + [ + "stage2.ram_read_write.output.eq.Cycle", + "stage2.ram_read_write.eval.RamRa", + "stage2.ram_read_write.output.partial.WeightedVal", + ], + ), + ], + relation_outputs: vec![Stage2RelationOutputPlan { + relation: "jolt.stage2.ram.read_write".to_owned(), + local_scalars: Vec::new(), + expected_output: "stage2.ram_read_write.output.claim_expr".to_owned(), + }], + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage2SumcheckClaimPlan { pub symbol: String, @@ -257,12 +362,14 @@ impl Stage2CpuProgram { let mut opening_inputs = Vec::new(); let mut field_constants = Vec::new(); let mut field_exprs = Vec::new(); + let mut scalar_exprs = Vec::new(); let mut kernels = Vec::new(); let mut claims = Vec::new(); let mut batches = Vec::new(); let mut drivers = Vec::new(); let mut instance_results = Vec::new(); let mut evals = Vec::new(); + let mut relation_outputs = Vec::new(); let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); let mut opening_claims = Vec::new(); @@ -519,22 +626,32 @@ impl Stage2CpuProgram { } } + let role = module + .role() + .ok_or_else(|| EmitError::new("missing cpu party role"))?; + if role == Role::Verifier { + let ram_read_write_output = stage2_ram_read_write_relation_output_plans(); + field_exprs.extend(ram_read_write_output.field_exprs); + scalar_exprs.extend(ram_read_write_output.scalar_exprs); + relation_outputs.extend(ram_read_write_output.relation_outputs); + } + Ok(Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, - role: module - .role() - .ok_or_else(|| EmitError::new("missing cpu party role"))?, + role, steps, transcript_squeezes, opening_inputs, field_constants, field_exprs, + scalar_exprs, kernels, claims, batches, drivers, instance_results, evals, + relation_outputs, point_slices, point_concats, opening_claims, @@ -604,6 +721,26 @@ impl Stage2CpuProgram { } } } + if self.role == Role::Verifier { + let field_values = self.verifier_scalar_sources(); + let point_values = self.verifier_point_sources(); + field_values.verify_no_conflicts("stage2")?; + point_values.verify_no_conflicts("stage2")?; + for expr in &self.scalar_exprs { + super::plan_tokens::verify_scalar_expr_operands( + super::plan_tokens::ScalarExprVerification { + stage: "stage2", + symbol: &expr.symbol, + formula: &expr.formula, + operand_names: &expr.operand_names, + operands: &expr.operands, + field_values: &field_values, + field_vector_values: None, + point_values: Some(&point_values), + }, + )?; + } + } for claim in &self.claims { if !field_values.contains(&claim.claim_value) { return Err(EmitError::new(format!( @@ -627,10 +764,66 @@ impl Stage2CpuProgram { .map(|squeeze| &squeeze.symbol), )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); + values.extend(symbols(self.scalar_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); values } + fn verifier_scalar_sources(&self) -> verifier_values::VerifierScalarSourceSet { + let mut values = verifier_values::VerifierScalarSourceSet::default(); + values.extend( + self.opening_inputs.iter().map(|input| &input.symbol), + verifier_values::VerifierScalarSourceKind::OpeningInput, + ); + values.extend( + self.field_constants.iter().map(|constant| &constant.symbol), + verifier_values::VerifierScalarSourceKind::FieldConstant, + ); + values.extend( + self.transcript_squeezes + .iter() + .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) + .map(|squeeze| &squeeze.symbol), + verifier_values::VerifierScalarSourceKind::TranscriptScalar, + ); + values.extend( + self.field_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::FieldExpr, + ); + values.extend( + self.scalar_exprs.iter().map(|expr| &expr.symbol), + verifier_values::VerifierScalarSourceKind::ScalarExpr, + ); + values.extend( + self.evals.iter().map(|eval| &eval.symbol), + verifier_values::VerifierScalarSourceKind::SumcheckEval, + ); + values + } + + fn verifier_point_sources(&self) -> verifier_values::VerifierPointSourceSet { + let mut values = verifier_values::VerifierPointSourceSet::default(); + values.extend( + self.opening_inputs.iter().map(|input| &input.symbol), + verifier_values::VerifierPointSourceKind::OpeningInput, + ); + values.extend( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + verifier_values::VerifierPointSourceKind::SumcheckInstance, + ); + values.extend( + self.point_slices.iter().map(|slice| &slice.symbol), + verifier_values::VerifierPointSourceKind::PointExpr, + ); + values.extend( + self.point_concats.iter().map(|concat| &concat.symbol), + verifier_values::VerifierPointSourceKind::PointExpr, + ); + values + } + fn verify_kernel_definitions(&self) -> Result<(), EmitError> { for kernel in &self.kernels { if kernel.backend != "cpu" { @@ -823,6 +1016,9 @@ impl Stage2CpuProgram { for expr in &self.field_exprs { let _ = FieldExprKind::from_cpu_attr(&expr.formula).map_err(rust_target_plan_error)?; } + for expr in &self.scalar_exprs { + let _ = ScalarExprKind::from_cpu_attr(&expr.formula).map_err(rust_target_plan_error)?; + } for claim in &self.claims { let relation = claim .relation @@ -843,6 +1039,10 @@ impl Stage2CpuProgram { let _ = JoltVerifierRelationKind::from_cpu_attr(&instance.relation) .map_err(rust_target_plan_error)?; } + for output in &self.relation_outputs { + let _ = JoltVerifierRelationKind::from_cpu_attr(&output.relation) + .map_err(rust_target_plan_error)?; + } for claim in &self.opening_claims { let _ = ClaimKind::from_cpu_attr(&claim.claim_kind).map_err(rust_target_plan_error)?; } @@ -1027,17 +1227,20 @@ pub type Stage2ChallengeVector = bolt_verifier_runtime::StageChallengeVector< pub type Stage2ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; pub type Stage2Proof = bolt_verifier_runtime::StageProof; pub type Stage2OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; -pub type Stage2VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlanNoEqualities; +pub type Stage2VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlan; pub type Stage2SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage2SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage2SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage2RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub use super::jolt_relations::JoltRelationKind as Stage2RelationKind; pub use bolt_verifier_runtime::{ ClaimKind as Stage2ClaimKind, FieldConstantPlan as Stage2FieldConstantPlan, FieldExprKind as Stage2FieldExprKind, FieldExprPlan as Stage2FieldExprPlan, + OpeningClaimEqualityPlan as Stage2OpeningClaimEqualityPlan, ScalarExprPlan as Stage2ScalarExprPlan, + ScalarExprKind as Stage2ScalarExprKind, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, OpeningInputPlan as Stage2OpeningInputPlan, PointExprKind as Stage2PointExprKind, PointExprPlan as Stage2PointExprPlan, ProgramStepKind as Stage2ProgramStepKind, @@ -1071,15 +1274,6 @@ pub struct Stage2RamData<'a> { pub output_layout: Option, } -#[derive(Clone, Copy, Debug)] -pub struct Stage2RamReadWriteOutputPlan { - pub cycle_point: &'static str, - pub gamma: &'static str, - pub val_eval: &'static str, - pub ra_eval: &'static str, - pub inc_eval: &'static str, -} - #[derive(Clone, Debug, Default)] struct Stage2ValueStore(bolt_verifier_runtime::ValueStore); @@ -1137,7 +1331,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); source.push_str(&self.emit_sumcheck_batch_constants()); source.push_str(&self.emit_verifier_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); - source.push_str(Self::emit_verifier_relation_output_constants()); + source.push_str(&self.emit_verifier_relation_output_constants()?); source.push_str( "pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan {\n\ \x20 params: STAGE2_PARAMS,\n\ @@ -1152,22 +1346,22 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); \x20 drivers: STAGE2_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE2_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE2_SUMCHECK_EVALS,\n\ + \x20 relation_outputs: STAGE2_RELATION_OUTPUTS,\n\ \x20 point_exprs: STAGE2_POINT_EXPRS,\n\ \x20 opening_claims: STAGE2_OPENING_CLAIMS,\n\ + \x20 opening_equalities: STAGE2_OPENING_EQUALITIES,\n\ \x20 opening_batches: STAGE2_OPENING_BATCHES,\n\ };\n", ); Ok(source) } - fn emit_verifier_relation_output_constants() -> &'static str { - "pub const STAGE2_RAM_READ_WRITE_OUTPUT: Stage2RamReadWriteOutputPlan = Stage2RamReadWriteOutputPlan {\n\ - \x20 cycle_point: \"stage2.input.stage1.RamReadValue\",\n\ - \x20 gamma: \"stage2.ram_read_write.gamma\",\n\ - \x20 val_eval: \"stage2.ram_read_write.eval.RamVal\",\n\ - \x20 ra_eval: \"stage2.ram_read_write.eval.RamRa\",\n\ - \x20 inc_eval: \"stage2.ram_read_write.eval.RamInc\",\n\ - };\n\n" + fn emit_verifier_relation_output_constants(&self) -> Result { + super::relation_outputs::emit_verifier_relation_output_constants( + "Stage2", + &self.role, + &self.relation_outputs, + ) } fn emit_shared_constants(&self) -> Result { @@ -1187,7 +1381,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); source.push_str(&self.emit_field_constant_constants()); source.push_str(&self.emit_field_expr_constants()?); if self.role == Role::Verifier { - source.push_str("pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[];\n"); + source.push_str(&self.emit_scalar_expr_constants()?); } Ok(source) } @@ -1344,6 +1538,27 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); Ok(source) } + fn emit_scalar_expr_constants(&self) -> Result { + let exprs = self + .scalar_exprs + .iter() + .map(|expr| { + let kind = ScalarExprKind::from_cpu_attr(&expr.formula) + .map_err(rust_target_plan_error)? + .rust_variant_expr(); + Ok(format!( + " Stage2ScalarExprPlan {{ symbol: {}, kind: Stage2ScalarExprKind::{kind}, operands: {} }},", + rust_str(&expr.symbol), + super::plan_tokens::rust_str_slice_expr(&expr.operands) + )) + }) + .collect::, EmitError>>()? + .join("\n"); + Ok(format!( + "pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[\n{exprs}\n];\n" + )) + } + fn emit_kernel_constants(&self) -> String { let kernels = self .kernels @@ -1584,6 +1799,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); source.push_str(&self.emit_sumcheck_eval_constants()); source.push_str(&self.emit_point_expr_constants()?); source.push_str(&self.emit_opening_claim_constants()?); + if self.role == Role::Verifier { + source.push_str( + "pub const STAGE2_OPENING_EQUALITIES: &[Stage2OpeningClaimEqualityPlan] = &[];\n", + ); + } source.push_str(&self.emit_opening_batch_constants()); Ok(source) } @@ -2240,10 +2460,15 @@ fn expected_batched_output_claim( })?; let value = match instance.relation { Stage2RelationKind::Stage2RamReadWrite => { - expected_ram_read_write( - &STAGE2_RAM_READ_WRITE_OUTPUT, - store, + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + &store.0, + instance, evals, + &[], + &[], local_point, )? } @@ -2264,23 +2489,6 @@ fn expected_batched_output_claim( Ok(expected) } -fn expected_ram_read_write( - plan: &'static Stage2RamReadWriteOutputPlan, - store: &Stage2ValueStore, - evals: &[Stage2NamedEval], - local_point: &[Fr], -) -> Result { - let r_cycle_stage1 = store.point(plan.cycle_point)?; - let log_t = r_cycle_stage1.len(); - let r_cycle = reverse_slice(&local_point[..log_t]); - let eq_eval = EqPolynomial::::mle(r_cycle_stage1, &r_cycle); - let gamma = store.scalar(plan.gamma)?; - let val = eval_by_name(evals, plan.val_eval)?; - let ra = eval_by_name(evals, plan.ra_eval)?; - let inc = eval_by_name(evals, plan.inc_eval)?; - Ok(eq_eval * ra * (val + gamma * (val + inc))) -} - fn expected_product_remainder( store: &Stage2ValueStore, evals: &[Stage2NamedEval], diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index a125f580e8..ec2ab16055 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -15,17 +15,19 @@ pub type Stage2ChallengeVector = bolt_verifier_runtime::StageChallengeVector< pub type Stage2ExecutionArtifacts = bolt_verifier_runtime::StageExecutionArtifacts; pub type Stage2Proof = bolt_verifier_runtime::StageProof; pub type Stage2OpeningInputValue = bolt_verifier_runtime::StageOpeningInputValue; -pub type Stage2VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlanNoEqualities; +pub type Stage2VerifierProgramPlan = bolt_verifier_runtime::StageVerifierProgramPlan; pub type Stage2SumcheckClaimPlan = bolt_verifier_runtime::SumcheckClaimPlan; pub type Stage2SumcheckDriverPlan = bolt_verifier_runtime::SumcheckDriverPlan; pub type Stage2SumcheckInstanceResultPlan = bolt_verifier_runtime::SumcheckInstanceResultPlan; +pub type Stage2RelationOutputPlan = bolt_verifier_runtime::RelationOutputPlan; pub use super::jolt_relations::JoltRelationKind as Stage2RelationKind; pub use bolt_verifier_runtime::{ ClaimKind as Stage2ClaimKind, FieldConstantPlan as Stage2FieldConstantPlan, FieldExprKind as Stage2FieldExprKind, FieldExprPlan as Stage2FieldExprPlan, - ScalarExprPlan as Stage2ScalarExprPlan, + OpeningClaimEqualityPlan as Stage2OpeningClaimEqualityPlan, + ScalarExprKind as Stage2ScalarExprKind, ScalarExprPlan as Stage2ScalarExprPlan, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, OpeningInputPlan as Stage2OpeningInputPlan, PointExprKind as Stage2PointExprKind, PointExprPlan as Stage2PointExprPlan, ProgramStepKind as Stage2ProgramStepKind, @@ -59,15 +61,6 @@ pub struct Stage2RamData<'a> { pub output_layout: Option, } -#[derive(Clone, Copy, Debug)] -pub struct Stage2RamReadWriteOutputPlan { - pub cycle_point: &'static str, - pub gamma: &'static str, - pub val_eval: &'static str, - pub ra_eval: &'static str, - pub inc_eval: &'static str, -} - #[derive(Clone, Debug, Default)] struct Stage2ValueStore(bolt_verifier_runtime::ValueStore); @@ -144,8 +137,14 @@ pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.RightOperand", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.LookupOutputLeftOperand", "stage2.instruction_lookup.term.RightLookupOperand"] }, Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.partial.LeftInstructionInput", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.RightOperand", "stage2.instruction_lookup.term.LeftInstructionInput"] }, Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.claim_reduction.claim_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.partial.LeftInstructionInput", "stage2.instruction_lookup.term.RightInstructionInput"] }, + Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.partial.ValPlusInc", kind: Stage2FieldExprKind::Add, operands: &["stage2.ram_read_write.eval.RamVal", "stage2.ram_read_write.eval.RamInc"] }, + Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.term.GammaValPlusInc", kind: Stage2FieldExprKind::Mul, operands: &["stage2.ram_read_write.gamma", "stage2.ram_read_write.output.partial.ValPlusInc"] }, + Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.partial.WeightedVal", kind: Stage2FieldExprKind::Add, operands: &["stage2.ram_read_write.eval.RamVal", "stage2.ram_read_write.output.term.GammaValPlusInc"] }, + Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.claim_expr", kind: Stage2FieldExprKind::Product, operands: &["stage2.ram_read_write.output.eq.Cycle", "stage2.ram_read_write.eval.RamRa", "stage2.ram_read_write.output.partial.WeightedVal"] }, +]; +pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[ + Stage2ScalarExprPlan { symbol: "stage2.ram_read_write.output.eq.Cycle", kind: Stage2ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage2.ram_read_write.instance", "stage2.input.stage1.RamReadValue"] }, ]; -pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[]; pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[ Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr" }, Stage2SumcheckClaimPlan { symbol: "stage2.ram_read_write.input", stage: "stage2", domain: "jolt.stage2_ram_rw_domain", num_rounds: 32, degree: 3, claim: "stage2.ram_read_write.weighted_values", kernel: None, relation: Some(Stage2RelationKind::Stage2RamReadWrite), claim_value: "stage2.ram_read_write.claim_expr" }, @@ -231,13 +230,10 @@ pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[ pub const STAGE2_OPENING_BATCHES: &[Stage2OpeningBatchPlan] = &[ Stage2OpeningBatchPlan { symbol: "stage2.openings", stage: "stage2", proof_slot: "stage2.openings", policy: "jolt_stage2_output_order", count: 18, ordered_claims: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"], claim_operands: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"] }, ]; -pub const STAGE2_RAM_READ_WRITE_OUTPUT: Stage2RamReadWriteOutputPlan = Stage2RamReadWriteOutputPlan { - cycle_point: "stage2.input.stage1.RamReadValue", - gamma: "stage2.ram_read_write.gamma", - val_eval: "stage2.ram_read_write.eval.RamVal", - ra_eval: "stage2.ram_read_write.eval.RamRa", - inc_eval: "stage2.ram_read_write.eval.RamInc", -}; +pub const STAGE2_OPENING_EQUALITIES: &[Stage2OpeningClaimEqualityPlan] = &[]; +pub const STAGE2_RELATION_OUTPUTS: &[Stage2RelationOutputPlan] = &[ + Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2RamReadWrite, local_scalars: &[], expected_output: "stage2.ram_read_write.output.claim_expr" }, +]; pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan { params: STAGE2_PARAMS, @@ -252,8 +248,10 @@ pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan drivers: STAGE2_SUMCHECK_DRIVERS, instance_results: STAGE2_SUMCHECK_INSTANCE_RESULTS, evals: STAGE2_SUMCHECK_EVALS, + relation_outputs: STAGE2_RELATION_OUTPUTS, point_exprs: STAGE2_POINT_EXPRS, opening_claims: STAGE2_OPENING_CLAIMS, + opening_equalities: STAGE2_OPENING_EQUALITIES, opening_batches: STAGE2_OPENING_BATCHES, }; @@ -686,10 +684,15 @@ fn expected_batched_output_claim( })?; let value = match instance.relation { Stage2RelationKind::Stage2RamReadWrite => { - expected_ram_read_write( - &STAGE2_RAM_READ_WRITE_OUTPUT, - store, + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + &store.0, + instance, evals, + &[], + &[], local_point, )? } @@ -710,23 +713,6 @@ fn expected_batched_output_claim( Ok(expected) } -fn expected_ram_read_write( - plan: &'static Stage2RamReadWriteOutputPlan, - store: &Stage2ValueStore, - evals: &[Stage2NamedEval], - local_point: &[Fr], -) -> Result { - let r_cycle_stage1 = store.point(plan.cycle_point)?; - let log_t = r_cycle_stage1.len(); - let r_cycle = reverse_slice(&local_point[..log_t]); - let eq_eval = EqPolynomial::::mle(r_cycle_stage1, &r_cycle); - let gamma = store.scalar(plan.gamma)?; - let val = eval_by_name(evals, plan.val_eval)?; - let ra = eval_by_name(evals, plan.ra_eval)?; - let inc = eval_by_name(evals, plan.inc_eval)?; - Ok(eq_eval * ra * (val + gamma * (val + inc))) -} - fn expected_product_remainder( store: &Stage2ValueStore, evals: &[Stage2NamedEval], From c20d0b10761a3dc1ba0c0c766b9eaf40da76cb02 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 03:43:24 -0600 Subject: [PATCH 133/171] refactor(bolt): type stage2 lookup output --- .../src/protocols/jolt/emit/rust/stage2.rs | 181 ++++++++++++------ crates/jolt-verifier/src/stages/stage2.rs | 63 +++--- 2 files changed, 145 insertions(+), 99 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 7b91808262..8f7f916922 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -141,18 +141,30 @@ fn stage2_scalar_expr( } } -fn stage2_ram_read_write_relation_output_plans() -> Stage2RelationOutputRows { +fn stage2_relation_output_plans() -> Stage2RelationOutputRows { Stage2RelationOutputRows { - scalar_exprs: vec![stage2_scalar_expr( - "stage2.ram_read_write.output.eq.Cycle", - structured_polynomial_scalar_formula( - "eq", "prefix", "y_point", "reverse", "full", "full", "as_is", + scalar_exprs: vec![ + stage2_scalar_expr( + "stage2.ram_read_write.output.eq.Cycle", + structured_polynomial_scalar_formula( + "eq", "prefix", "y_point", "reverse", "full", "full", "as_is", + ), + [ + "stage2.ram_read_write.instance", + "stage2.input.stage1.RamReadValue", + ], + ), + stage2_scalar_expr( + "stage2.instruction_lookup.output.eq.LookupOutput", + structured_polynomial_scalar_formula( + "eq", "full", "full", "reverse", "full", "full", "as_is", + ), + [ + "stage2.instruction_lookup.claim_reduction.instance", + "stage2.input.stage1.LookupOutput", + ], ), - [ - "stage2.ram_read_write.instance", - "stage2.input.stage1.RamReadValue", - ], - )], + ], field_exprs: vec![ stage2_field_expr( "stage2.ram_read_write.output.partial.ValPlusInc", @@ -187,12 +199,91 @@ fn stage2_ram_read_write_relation_output_plans() -> Stage2RelationOutputRows { "stage2.ram_read_write.output.partial.WeightedVal", ], ), + stage2_field_expr( + "stage2.instruction_lookup.output.term.LeftLookupOperand", + "field.mul", + [ + "stage2.instruction_lookup.gamma", + "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand", + ], + ), + stage2_field_expr( + "stage2.instruction_lookup.output.term.RightLookupOperand", + "field.mul", + [ + "stage2.instruction_lookup.gamma2", + "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand", + ], + ), + stage2_field_expr( + "stage2.instruction_lookup.output.term.LeftInstructionInput", + "field.mul", + [ + "stage2.instruction_lookup.gamma3", + "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput", + ], + ), + stage2_field_expr( + "stage2.instruction_lookup.output.term.RightInstructionInput", + "field.mul", + [ + "stage2.instruction_lookup.gamma4", + "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput", + ], + ), + stage2_field_expr( + "stage2.instruction_lookup.output.partial.LookupOutputLeftOperand", + "field.add", + [ + "stage2.instruction_lookup.claim_reduction.eval.LookupOutput", + "stage2.instruction_lookup.output.term.LeftLookupOperand", + ], + ), + stage2_field_expr( + "stage2.instruction_lookup.output.partial.RightOperand", + "field.add", + [ + "stage2.instruction_lookup.output.partial.LookupOutputLeftOperand", + "stage2.instruction_lookup.output.term.RightLookupOperand", + ], + ), + stage2_field_expr( + "stage2.instruction_lookup.output.partial.LeftInstructionInput", + "field.add", + [ + "stage2.instruction_lookup.output.partial.RightOperand", + "stage2.instruction_lookup.output.term.LeftInstructionInput", + ], + ), + stage2_field_expr( + "stage2.instruction_lookup.output.weighted_expr", + "field.add", + [ + "stage2.instruction_lookup.output.partial.LeftInstructionInput", + "stage2.instruction_lookup.output.term.RightInstructionInput", + ], + ), + stage2_field_expr( + "stage2.instruction_lookup.output.claim_expr", + "field.mul", + [ + "stage2.instruction_lookup.output.eq.LookupOutput", + "stage2.instruction_lookup.output.weighted_expr", + ], + ), + ], + relation_outputs: vec![ + Stage2RelationOutputPlan { + relation: "jolt.stage2.ram.read_write".to_owned(), + local_scalars: Vec::new(), + expected_output: "stage2.ram_read_write.output.claim_expr".to_owned(), + }, + Stage2RelationOutputPlan { + relation: "jolt.stage2.instruction_lookup.claim_reduction".to_owned(), + local_scalars: Vec::new(), + expected_output: "stage2.instruction_lookup.output.claim_expr".to_owned(), + }, ], - relation_outputs: vec![Stage2RelationOutputPlan { - relation: "jolt.stage2.ram.read_write".to_owned(), - local_scalars: Vec::new(), - expected_output: "stage2.ram_read_write.output.claim_expr".to_owned(), - }], } } @@ -630,10 +721,10 @@ impl Stage2CpuProgram { .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; if role == Role::Verifier { - let ram_read_write_output = stage2_ram_read_write_relation_output_plans(); - field_exprs.extend(ram_read_write_output.field_exprs); - scalar_exprs.extend(ram_read_write_output.scalar_exprs); - relation_outputs.extend(ram_read_write_output.relation_outputs); + let relation_output_rows = stage2_relation_output_plans(); + field_exprs.extend(relation_output_rows.field_exprs); + scalar_exprs.extend(relation_output_rows.scalar_exprs); + relation_outputs.extend(relation_output_rows.relation_outputs); } Ok(Self { @@ -1211,7 +1302,7 @@ impl Stage2CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ - use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt, RingCore};\n\ + use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt};\n\ use jolt_poly::lagrange::{lagrange_evals, lagrange_kernel_eval};\n\ use jolt_poly::{EqPolynomial, UnivariatePoly};\n\ use jolt_sumcheck::{CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier};\n\ @@ -2476,7 +2567,17 @@ fn expected_batched_output_claim( expected_product_remainder(store, evals, local_point)? } Stage2RelationKind::Stage2InstructionLookupClaimReduction => { - expected_instruction_lookup(store, evals, local_point)? + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + &store.0, + instance, + evals, + &[], + &[], + local_point, + )? } Stage2RelationKind::Stage2RamRafEvaluation => expected_ram_raf(evals, local_point, ram)?, Stage2RelationKind::Stage2RamOutputCheck => { @@ -2529,44 +2630,6 @@ fn expected_product_remainder( Ok(high * low * left * right) } -fn expected_instruction_lookup( - store: &Stage2ValueStore, - evals: &[Stage2NamedEval], - local_point: &[Fr], -) -> Result { - let opening_point = reverse_slice(local_point); - let r_spartan = store.point("stage2.input.stage1.LookupOutput")?; - let eq_eval = EqPolynomial::::mle(&opening_point, r_spartan); - let gamma = store.scalar("stage2.instruction_lookup.gamma")?; - let gamma2 = gamma.square(); - let gamma3 = gamma2 * gamma; - let gamma4 = gamma2.square(); - let weighted = eval_by_name( - evals, - "stage2.instruction_lookup.claim_reduction.eval.LookupOutput", - )? + gamma - * eval_by_name( - evals, - "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand", - )? - + gamma2 - * eval_by_name( - evals, - "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand", - )? - + gamma3 - * eval_by_name( - evals, - "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput", - )? - + gamma4 - * eval_by_name( - evals, - "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput", - )?; - Ok(eq_eval * weighted) -} - fn expected_ram_raf( evals: &[Stage2NamedEval], local_point: &[Fr], diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index ec2ab16055..e50af3bacf 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; -use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt, RingCore}; +use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt}; use jolt_poly::lagrange::{lagrange_evals, lagrange_kernel_eval}; use jolt_poly::{EqPolynomial, UnivariatePoly}; use jolt_sumcheck::{CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier}; @@ -141,9 +141,19 @@ pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.term.GammaValPlusInc", kind: Stage2FieldExprKind::Mul, operands: &["stage2.ram_read_write.gamma", "stage2.ram_read_write.output.partial.ValPlusInc"] }, Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.partial.WeightedVal", kind: Stage2FieldExprKind::Add, operands: &["stage2.ram_read_write.eval.RamVal", "stage2.ram_read_write.output.term.GammaValPlusInc"] }, Stage2FieldExprPlan { symbol: "stage2.ram_read_write.output.claim_expr", kind: Stage2FieldExprKind::Product, operands: &["stage2.ram_read_write.output.eq.Cycle", "stage2.ram_read_write.eval.RamRa", "stage2.ram_read_write.output.partial.WeightedVal"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.term.LeftLookupOperand", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma", "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.term.RightLookupOperand", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma2", "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.term.LeftInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma3", "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.term.RightInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.gamma4", "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.partial.LookupOutputLeftOperand", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.claim_reduction.eval.LookupOutput", "stage2.instruction_lookup.output.term.LeftLookupOperand"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.partial.RightOperand", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.output.partial.LookupOutputLeftOperand", "stage2.instruction_lookup.output.term.RightLookupOperand"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.partial.LeftInstructionInput", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.output.partial.RightOperand", "stage2.instruction_lookup.output.term.LeftInstructionInput"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.weighted_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.output.partial.LeftInstructionInput", "stage2.instruction_lookup.output.term.RightInstructionInput"] }, + Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.claim_expr", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.output.eq.LookupOutput", "stage2.instruction_lookup.output.weighted_expr"] }, ]; pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[ Stage2ScalarExprPlan { symbol: "stage2.ram_read_write.output.eq.Cycle", kind: Stage2ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage2.ram_read_write.instance", "stage2.input.stage1.RamReadValue"] }, + Stage2ScalarExprPlan { symbol: "stage2.instruction_lookup.output.eq.LookupOutput", kind: Stage2ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage2.instruction_lookup.claim_reduction.instance", "stage2.input.stage1.LookupOutput"] }, ]; pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[ Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr" }, @@ -233,6 +243,7 @@ pub const STAGE2_OPENING_BATCHES: &[Stage2OpeningBatchPlan] = &[ pub const STAGE2_OPENING_EQUALITIES: &[Stage2OpeningClaimEqualityPlan] = &[]; pub const STAGE2_RELATION_OUTPUTS: &[Stage2RelationOutputPlan] = &[ Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2RamReadWrite, local_scalars: &[], expected_output: "stage2.ram_read_write.output.claim_expr" }, + Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2InstructionLookupClaimReduction, local_scalars: &[], expected_output: "stage2.instruction_lookup.output.claim_expr" }, ]; pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan { @@ -700,7 +711,17 @@ fn expected_batched_output_claim( expected_product_remainder(store, evals, local_point)? } Stage2RelationKind::Stage2InstructionLookupClaimReduction => { - expected_instruction_lookup(store, evals, local_point)? + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + &store.0, + instance, + evals, + &[], + &[], + local_point, + )? } Stage2RelationKind::Stage2RamRafEvaluation => expected_ram_raf(evals, local_point, ram)?, Stage2RelationKind::Stage2RamOutputCheck => { @@ -753,44 +774,6 @@ fn expected_product_remainder( Ok(high * low * left * right) } -fn expected_instruction_lookup( - store: &Stage2ValueStore, - evals: &[Stage2NamedEval], - local_point: &[Fr], -) -> Result { - let opening_point = reverse_slice(local_point); - let r_spartan = store.point("stage2.input.stage1.LookupOutput")?; - let eq_eval = EqPolynomial::::mle(&opening_point, r_spartan); - let gamma = store.scalar("stage2.instruction_lookup.gamma")?; - let gamma2 = gamma.square(); - let gamma3 = gamma2 * gamma; - let gamma4 = gamma2.square(); - let weighted = eval_by_name( - evals, - "stage2.instruction_lookup.claim_reduction.eval.LookupOutput", - )? + gamma - * eval_by_name( - evals, - "stage2.instruction_lookup.claim_reduction.eval.LeftLookupOperand", - )? - + gamma2 - * eval_by_name( - evals, - "stage2.instruction_lookup.claim_reduction.eval.RightLookupOperand", - )? - + gamma3 - * eval_by_name( - evals, - "stage2.instruction_lookup.claim_reduction.eval.LeftInstructionInput", - )? - + gamma4 - * eval_by_name( - evals, - "stage2.instruction_lookup.claim_reduction.eval.RightInstructionInput", - )?; - Ok(eq_eval * weighted) -} - fn expected_ram_raf( evals: &[Stage2NamedEval], local_point: &[Fr], From 25c15108b7f8a7184b312b0d53e1e0a1eea43bd2 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 03:58:27 -0600 Subject: [PATCH 134/171] refactor(bolt): type stage2 product remainder --- crates/bolt-verifier-runtime/src/lib.rs | 94 ++++++++- .../protocols/jolt/emit/rust/plan_tokens.rs | 19 ++ .../src/protocols/jolt/emit/rust/stage2.rs | 191 ++++++++++++++---- .../src/protocols/jolt/rust_target_plan.rs | 74 +++++++ crates/jolt-verifier/src/stages/stage2.rs | 71 +++---- 5 files changed, 359 insertions(+), 90 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 5479cdb26e..75885aaeef 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -8,7 +8,10 @@ use std::fmt; use std::marker::PhantomData; use jolt_field::{Field, Fr, MulPow2}; -use jolt_poly::{lagrange::lagrange_evals, EqPlusOnePolynomial, EqPolynomial, LtPolynomial}; +use jolt_poly::{ + lagrange::{lagrange_evals, lagrange_kernel_eval}, + EqPlusOnePolynomial, EqPolynomial, LtPolynomial, +}; use jolt_sumcheck::{ CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckProof, SumcheckVerifier, }; @@ -249,6 +252,7 @@ pub enum FieldExprKind { Neg, Pow(usize), LagrangeBasisEval(i64, usize, usize), + LagrangeKernelEval(i64, usize), } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -274,6 +278,9 @@ pub enum ScalarExprKind { shared_term_offsets: &'static [usize], row_term_offsets: &'static [usize], }, + PointElement { + index: usize, + }, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -1059,6 +1066,13 @@ impl ValueStore { .iter() .map(|operand| self.try_scalar(operand)) .collect(), + ScalarExprKind::PointElement { index } => { + let [symbol] = expr.operands else { + return Some(Vec::new()); + }; + self.try_point(symbol) + .map(|point| point.get(index).copied().into_iter().collect()) + } } } @@ -1582,6 +1596,27 @@ fn evaluate_relation_output_scalar_expr( .map(|operands| evaluate_scalar_expr(expr, &operands).map(Some)) .transpose() .map(Option::flatten), + ScalarExprKind::PointElement { index } => { + let [source] = expr.operands else { + return evaluate_scalar_expr(expr, &[]).map(Some); + }; + let point = relation_output_x_point_source( + source, + context.instance_symbol, + context.local_points, + context.local_point, + store, + )?; + let value = point + .get(index) + .copied() + .ok_or(RuntimePlanError::InvalidInputLength { + input: expr.symbol, + expected: index + 1, + actual: point.len(), + })?; + Ok(Some(value)) + } } } @@ -1717,6 +1752,15 @@ pub fn evaluate_field_expr( actual: weights.len(), }) } + FieldExprKind::LagrangeKernelEval(domain_start, domain_size) => { + require_operand_count(expr.symbol, 2, operands.len())?; + Ok(lagrange_kernel_eval( + domain_start, + domain_size, + operands[0], + operands[1], + )) + } } } @@ -1759,6 +1803,10 @@ pub fn evaluate_scalar_expr( shared_term_offsets, row_term_offsets, ), + ScalarExprKind::PointElement { index: _ } => { + require_operand_count(expr.symbol, 1, operands.len())?; + Ok(operands[0]) + } } } @@ -1955,11 +2003,12 @@ pub fn reverse_slice(values: &[Fr]) -> Vec { )] mod tests { use super::{ - evaluate_relation_output_for_instance, evaluate_scalar_expr, Fr, NamedEvalFamilyPlan, - RelationOutputPlan, RuntimePlanError, ScalarExprKind, ScalarExprPlan, - StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, - StructuredPolynomialPointSegment, StructuredPolynomialPointTransform, - SumcheckInstanceResultPlan, SumcheckPointOrder, ValueStore, + evaluate_relation_output_for_instance, evaluate_scalar_expr, FieldExprKind, FieldExprPlan, + Fr, NamedEvalFamilyPlan, RelationOutputPlan, RuntimePlanError, ScalarExprKind, + ScalarExprPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, + StructuredPolynomialPointOrder, StructuredPolynomialPointSegment, + StructuredPolynomialPointTransform, SumcheckInstanceResultPlan, SumcheckPointOrder, + ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -2031,6 +2080,39 @@ mod tests { assert_eq!(store.try_scalar("family.ab.sum"), Some(Fr::from_u64(5))); } + #[test] + fn value_store_evaluates_point_element_and_lagrange_kernel_exprs() { + let mut store = ValueStore::default(); + store.insert_point("point.r", vec![Fr::from_u64(2)]); + store.insert_scalar("tau", Fr::from_u64(5)); + + store + .evaluate_available_exprs( + &[FieldExprPlan { + symbol: "kernel", + kind: FieldExprKind::LagrangeKernelEval(-1, 3), + operands: &["tau", "r0"], + }], + &[ScalarExprPlan { + symbol: "r0", + kind: ScalarExprKind::PointElement { index: 0 }, + operands: &["point.r"], + }], + ) + .unwrap(); + + assert_eq!(store.try_scalar("r0"), Some(Fr::from_u64(2))); + assert_eq!( + store.try_scalar("kernel"), + Some(jolt_poly::lagrange::lagrange_kernel_eval( + -1, + 3, + Fr::from_u64(5), + Fr::from_u64(2), + )) + ); + } + #[test] fn scalar_expr_evaluates_power_strided_weighted_sum() { let value = evaluate_scalar_expr( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index 938337964f..2c1983480b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -224,6 +224,25 @@ pub(super) fn verify_scalar_expr_operands( } } } + ScalarExprKind::PointElement { .. } => { + verify_count( + "point element scalar expr operands", + symbol, + 1, + operands.len(), + )?; + let Some(point_values) = point_values else { + return Err(EmitError::new(format!( + "{stage} scalar expr @{symbol} uses point element formula without point sources" + ))); + }; + let operand = &operands[0]; + if !point_values.contains(operand) { + return Err(EmitError::new(format!( + "point element scalar expr @{symbol} references missing point @{operand}" + ))); + } + } } Ok(()) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 8f7f916922..d20eb380b0 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -106,6 +106,7 @@ pub struct Stage2ScalarExprPlan { #[derive(Clone, Debug, PartialEq, Eq)] struct Stage2RelationOutputRows { + field_constants: Vec, field_exprs: Vec, scalar_exprs: Vec, relation_outputs: Vec, @@ -143,6 +144,11 @@ fn stage2_scalar_expr( fn stage2_relation_output_plans() -> Stage2RelationOutputRows { Stage2RelationOutputRows { + field_constants: vec![Stage2FieldConstantPlan { + symbol: "stage2.product_virtual.remainder.one".to_owned(), + field: "bn254_fr".to_owned(), + value: 1, + }], scalar_exprs: vec![ stage2_scalar_expr( "stage2.ram_read_write.output.eq.Cycle", @@ -164,6 +170,21 @@ fn stage2_relation_output_plans() -> Stage2RelationOutputRows { "stage2.input.stage1.LookupOutput", ], ), + stage2_scalar_expr( + "stage2.product_virtual.remainder.point.UniskipR0", + "point.element:0".to_owned(), + ["stage2.product_virtual.uniskip.sumcheck"], + ), + stage2_scalar_expr( + "stage2.product_virtual.remainder.output.eq.Product", + structured_polynomial_scalar_formula( + "eq", "full", "full", "reverse", "full", "full", "as_is", + ), + [ + "stage2.product_virtual.remainder.instance", + "stage2.input.stage1.Product", + ], + ), ], field_exprs: vec![ stage2_field_expr( @@ -271,6 +292,113 @@ fn stage2_relation_output_plans() -> Stage2RelationOutputRows { "stage2.instruction_lookup.output.weighted_expr", ], ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.high", + "poly.lagrange_kernel_eval:-1:3", + [ + "stage2.product_virtual.tau_high", + "stage2.product_virtual.remainder.point.UniskipR0", + ], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.weight.Product", + "poly.lagrange_basis_eval:-1:3:0", + ["stage2.product_virtual.remainder.point.UniskipR0"], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.weight.ShouldBranch", + "poly.lagrange_basis_eval:-1:3:1", + ["stage2.product_virtual.remainder.point.UniskipR0"], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.weight.ShouldJump", + "poly.lagrange_basis_eval:-1:3:2", + ["stage2.product_virtual.remainder.point.UniskipR0"], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.left.LeftInstructionInput", + "field.mul", + [ + "stage2.product_virtual.remainder.output.weight.Product", + "stage2.product_virtual.remainder.eval.LeftInstructionInput", + ], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.left.LookupOutput", + "field.mul", + [ + "stage2.product_virtual.remainder.output.weight.ShouldBranch", + "stage2.product_virtual.remainder.eval.LookupOutput", + ], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.left.OpFlagJump", + "field.mul", + [ + "stage2.product_virtual.remainder.output.weight.ShouldJump", + "stage2.product_virtual.remainder.eval.OpFlagJump", + ], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.left.weighted_expr", + "field.sum", + [ + "stage2.product_virtual.remainder.output.left.LeftInstructionInput", + "stage2.product_virtual.remainder.output.left.LookupOutput", + "stage2.product_virtual.remainder.output.left.OpFlagJump", + ], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.right.RightInstructionInput", + "field.mul", + [ + "stage2.product_virtual.remainder.output.weight.Product", + "stage2.product_virtual.remainder.eval.RightInstructionInput", + ], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.right.InstructionFlagBranch", + "field.mul", + [ + "stage2.product_virtual.remainder.output.weight.ShouldBranch", + "stage2.product_virtual.remainder.eval.InstructionFlagBranch", + ], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.partial.NotNextIsNoop", + "field.sub", + [ + "stage2.product_virtual.remainder.one", + "stage2.product_virtual.remainder.eval.NextIsNoop", + ], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.right.NextIsNoop", + "field.mul", + [ + "stage2.product_virtual.remainder.output.weight.ShouldJump", + "stage2.product_virtual.remainder.output.partial.NotNextIsNoop", + ], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.right.weighted_expr", + "field.sum", + [ + "stage2.product_virtual.remainder.output.right.RightInstructionInput", + "stage2.product_virtual.remainder.output.right.InstructionFlagBranch", + "stage2.product_virtual.remainder.output.right.NextIsNoop", + ], + ), + stage2_field_expr( + "stage2.product_virtual.remainder.output.claim_expr", + "field.product", + [ + "stage2.product_virtual.remainder.output.high", + "stage2.product_virtual.remainder.output.eq.Product", + "stage2.product_virtual.remainder.output.left.weighted_expr", + "stage2.product_virtual.remainder.output.right.weighted_expr", + ], + ), ], relation_outputs: vec![ Stage2RelationOutputPlan { @@ -283,6 +411,11 @@ fn stage2_relation_output_plans() -> Stage2RelationOutputRows { local_scalars: Vec::new(), expected_output: "stage2.instruction_lookup.output.claim_expr".to_owned(), }, + Stage2RelationOutputPlan { + relation: "jolt.stage2.product_virtual.remainder".to_owned(), + local_scalars: Vec::new(), + expected_output: "stage2.product_virtual.remainder.output.claim_expr".to_owned(), + }, ], } } @@ -722,6 +855,7 @@ impl Stage2CpuProgram { .ok_or_else(|| EmitError::new("missing cpu party role"))?; if role == Role::Verifier { let relation_output_rows = stage2_relation_output_plans(); + field_constants.extend(relation_output_rows.field_constants); field_exprs.extend(relation_output_rows.field_exprs); scalar_exprs.extend(relation_output_rows.scalar_exprs); relation_outputs.extend(relation_output_rows.relation_outputs); @@ -898,6 +1032,10 @@ impl Stage2CpuProgram { self.opening_inputs.iter().map(|input| &input.symbol), verifier_values::VerifierPointSourceKind::OpeningInput, ); + values.extend( + self.drivers.iter().map(|driver| &driver.symbol), + verifier_values::VerifierPointSourceKind::SumcheckInstance, + ); values.extend( self.instance_results .iter() @@ -1303,7 +1441,6 @@ impl Stage2CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt};\n\ - use jolt_poly::lagrange::{lagrange_evals, lagrange_kernel_eval};\n\ use jolt_poly::{EqPolynomial, UnivariatePoly};\n\ use jolt_sumcheck::{CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier};\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -2564,7 +2701,17 @@ fn expected_batched_output_claim( )? } Stage2RelationKind::Stage2ProductVirtualRemainder => { - expected_product_remainder(store, evals, local_point)? + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + &store.0, + instance, + evals, + &[], + &[], + local_point, + )? } Stage2RelationKind::Stage2InstructionLookupClaimReduction => { bolt_verifier_runtime::evaluate_relation_output_for_instance( @@ -2590,46 +2737,6 @@ fn expected_batched_output_claim( Ok(expected) } -fn expected_product_remainder( - store: &Stage2ValueStore, - evals: &[Stage2NamedEval], - local_point: &[Fr], -) -> Result { - let tau_low = store.point("stage2.input.stage1.Product")?; - let tau_high = store.scalar("stage2.product_virtual.tau_high")?; - let r0 = *store - .point("stage2.product_virtual.uniskip.sumcheck")? - .first() - .ok_or(VerifyStage2Error::MissingValue { - symbol: "stage2.product_virtual.uniskip.sumcheck", - })?; - let r_tail = reverse_slice(local_point); - let low = EqPolynomial::::mle(tau_low, &r_tail); - let high = lagrange_kernel_eval( - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START, - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE, - tau_high, - r0, - ); - let weights = lagrange_evals( - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START, - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE, - r0, - ); - let left = weights[0] - * eval_by_name(evals, "stage2.product_virtual.remainder.eval.LeftInstructionInput")? - + weights[1] * eval_by_name(evals, "stage2.product_virtual.remainder.eval.LookupOutput")? - + weights[2] * eval_by_name(evals, "stage2.product_virtual.remainder.eval.OpFlagJump")?; - let right = weights[0] - * eval_by_name(evals, "stage2.product_virtual.remainder.eval.RightInstructionInput")? - + weights[1] - * eval_by_name(evals, "stage2.product_virtual.remainder.eval.InstructionFlagBranch")? - + weights[2] - * (Fr::from_u64(1) - - eval_by_name(evals, "stage2.product_virtual.remainder.eval.NextIsNoop")?); - Ok(high * low * left * right) -} - fn expected_ram_raf( evals: &[Stage2NamedEval], local_point: &[Fr], diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index c5e8ea90fe..803e1af7d4 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -263,6 +263,10 @@ pub(crate) enum FieldExprKind { domain_size: usize, index: usize, }, + LagrangeKernelEval { + domain_start: i64, + domain_size: usize, + }, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -281,6 +285,9 @@ pub(crate) enum ScalarExprKind { shared_term_offsets: Vec, row_term_offsets: Vec, }, + PointElement { + index: usize, + }, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -329,6 +336,9 @@ impl FieldExprKind { "field.neg" => Ok(Self::Neg), value if value.starts_with("field.pow:") => parse_pow(value), value if value.starts_with("poly.lagrange_basis_eval:") => parse_lagrange(value), + value if value.starts_with("poly.lagrange_kernel_eval:") => { + parse_lagrange_kernel(value) + } _ => Err(RustTargetPlanError::unsupported( "field expression formula", value, @@ -351,6 +361,10 @@ impl FieldExprKind { domain_size, index, } => format!("LagrangeBasisEval({domain_start}, {domain_size}, {index})"), + Self::LagrangeKernelEval { + domain_start, + domain_size, + } => format!("LagrangeKernelEval({domain_start}, {domain_size})"), } } } @@ -366,6 +380,7 @@ impl ScalarExprKind { value if value.starts_with("field.power_strided_weighted_sum:") => { parse_power_strided_weighted_sum(value) } + value if value.starts_with("point.element:") => parse_point_element(value), _ => Err(RustTargetPlanError::unsupported( "scalar expression formula", value, @@ -399,6 +414,9 @@ impl ScalarExprKind { usize_slice_expr(shared_term_offsets), usize_slice_expr(row_term_offsets), ), + Self::PointElement { index } => { + format!("PointElement {{ index: {index} }}") + } } } } @@ -589,6 +607,29 @@ fn parse_lagrange(value: &str) -> Result { }) } +fn parse_lagrange_kernel(value: &str) -> Result { + let spec = value + .strip_prefix("poly.lagrange_kernel_eval:") + .ok_or_else(|| RustTargetPlanError::unsupported("field expression formula", value))?; + let parts = spec.split(':').collect::>(); + let [domain_start, domain_size] = parts.as_slice() else { + return Err(RustTargetPlanError::unsupported( + "field expression formula", + value, + )); + }; + let domain_start = domain_start + .parse::() + .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; + let domain_size = domain_size + .parse::() + .map_err(|_| RustTargetPlanError::unsupported("field expression formula", value))?; + Ok(FieldExprKind::LagrangeKernelEval { + domain_start, + domain_size, + }) +} + fn parse_power_strided_weighted_sum(value: &str) -> Result { let spec = value .strip_prefix("field.power_strided_weighted_sum:") @@ -616,6 +657,14 @@ fn parse_power_strided_weighted_sum(value: &str) -> Result Result { + let index = value + .strip_prefix("point.element:") + .and_then(|index| index.parse::().ok()) + .ok_or_else(|| RustTargetPlanError::unsupported("scalar expression formula", value))?; + Ok(ScalarExprKind::PointElement { index }) +} + fn parse_structured_polynomial_scalar(value: &str) -> Result { let spec = value .strip_prefix("poly.structured_eval:") @@ -760,9 +809,17 @@ mod tests { index: 2, }) ); + assert_eq!( + FieldExprKind::from_cpu_attr("poly.lagrange_kernel_eval:-1:3").ok(), + Some(FieldExprKind::LagrangeKernelEval { + domain_start: -1, + domain_size: 3, + }) + ); assert!(FieldExprKind::from_cpu_attr("field_vector.sum").is_err()); assert!(FieldExprKind::from_cpu_attr("field.pow:nope").is_err()); assert!(FieldExprKind::from_cpu_attr("poly.lagrange_basis_eval:1:2").is_err()); + assert!(FieldExprKind::from_cpu_attr("poly.lagrange_kernel_eval:1").is_err()); } #[test] @@ -804,8 +861,13 @@ mod tests { }, }) ); + assert_eq!( + ScalarExprKind::from_cpu_attr("point.element:0").ok(), + Some(ScalarExprKind::PointElement { index: 0 }) + ); assert!(ScalarExprKind::from_cpu_attr("field.power_strided_weighted_sum:1:2:0").is_err()); assert!(ScalarExprKind::from_cpu_attr("poly.structured_eval:eq:full").is_err()); + assert!(ScalarExprKind::from_cpu_attr("point.element:nope").is_err()); } #[test] @@ -823,6 +885,14 @@ mod tests { .rust_variant_expr(), "LagrangeBasisEval(-1, 3, 0)" ); + assert_eq!( + FieldExprKind::LagrangeKernelEval { + domain_start: -1, + domain_size: 3, + } + .rust_variant_expr(), + "LagrangeKernelEval(-1, 3)" + ); assert_eq!( ScalarExprKind::PowerStridedWeightedSum { row_count: 39, @@ -851,5 +921,9 @@ mod tests { .rust_variant_expr(), "StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::EqPlusOne, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }" ); + assert_eq!( + ScalarExprKind::PointElement { index: 7 }.rust_variant_expr(), + "PointElement { index: 7 }" + ); } } diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index e50af3bacf..6af2e76b0a 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -2,7 +2,6 @@ use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt}; -use jolt_poly::lagrange::{lagrange_evals, lagrange_kernel_eval}; use jolt_poly::{EqPolynomial, UnivariatePoly}; use jolt_sumcheck::{CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier}; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -113,6 +112,7 @@ pub const STAGE2_OPENING_INPUTS: &[Stage2OpeningInputPlan] = &[ pub const STAGE2_FIELD_CONSTANTS: &[Stage2FieldConstantPlan] = &[ Stage2FieldConstantPlan { symbol: "stage2.ram_output.zero", field: "bn254_fr", value: 0 }, + Stage2FieldConstantPlan { symbol: "stage2.product_virtual.remainder.one", field: "bn254_fr", value: 1 }, ]; pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ @@ -150,10 +150,26 @@ pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.partial.LeftInstructionInput", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.output.partial.RightOperand", "stage2.instruction_lookup.output.term.LeftInstructionInput"] }, Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.weighted_expr", kind: Stage2FieldExprKind::Add, operands: &["stage2.instruction_lookup.output.partial.LeftInstructionInput", "stage2.instruction_lookup.output.term.RightInstructionInput"] }, Stage2FieldExprPlan { symbol: "stage2.instruction_lookup.output.claim_expr", kind: Stage2FieldExprKind::Mul, operands: &["stage2.instruction_lookup.output.eq.LookupOutput", "stage2.instruction_lookup.output.weighted_expr"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.high", kind: Stage2FieldExprKind::LagrangeKernelEval(-1, 3), operands: &["stage2.product_virtual.tau_high", "stage2.product_virtual.remainder.point.UniskipR0"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.weight.Product", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 0), operands: &["stage2.product_virtual.remainder.point.UniskipR0"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.weight.ShouldBranch", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 1), operands: &["stage2.product_virtual.remainder.point.UniskipR0"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.weight.ShouldJump", kind: Stage2FieldExprKind::LagrangeBasisEval(-1, 3, 2), operands: &["stage2.product_virtual.remainder.point.UniskipR0"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.left.LeftInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.Product", "stage2.product_virtual.remainder.eval.LeftInstructionInput"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.left.LookupOutput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.ShouldBranch", "stage2.product_virtual.remainder.eval.LookupOutput"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.left.OpFlagJump", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.ShouldJump", "stage2.product_virtual.remainder.eval.OpFlagJump"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.left.weighted_expr", kind: Stage2FieldExprKind::Sum, operands: &["stage2.product_virtual.remainder.output.left.LeftInstructionInput", "stage2.product_virtual.remainder.output.left.LookupOutput", "stage2.product_virtual.remainder.output.left.OpFlagJump"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.right.RightInstructionInput", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.Product", "stage2.product_virtual.remainder.eval.RightInstructionInput"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.right.InstructionFlagBranch", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.ShouldBranch", "stage2.product_virtual.remainder.eval.InstructionFlagBranch"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.partial.NotNextIsNoop", kind: Stage2FieldExprKind::Sub, operands: &["stage2.product_virtual.remainder.one", "stage2.product_virtual.remainder.eval.NextIsNoop"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.right.NextIsNoop", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.ShouldJump", "stage2.product_virtual.remainder.output.partial.NotNextIsNoop"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.right.weighted_expr", kind: Stage2FieldExprKind::Sum, operands: &["stage2.product_virtual.remainder.output.right.RightInstructionInput", "stage2.product_virtual.remainder.output.right.InstructionFlagBranch", "stage2.product_virtual.remainder.output.right.NextIsNoop"] }, + Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.claim_expr", kind: Stage2FieldExprKind::Product, operands: &["stage2.product_virtual.remainder.output.high", "stage2.product_virtual.remainder.output.eq.Product", "stage2.product_virtual.remainder.output.left.weighted_expr", "stage2.product_virtual.remainder.output.right.weighted_expr"] }, ]; pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[ Stage2ScalarExprPlan { symbol: "stage2.ram_read_write.output.eq.Cycle", kind: Stage2ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage2.ram_read_write.instance", "stage2.input.stage1.RamReadValue"] }, Stage2ScalarExprPlan { symbol: "stage2.instruction_lookup.output.eq.LookupOutput", kind: Stage2ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage2.instruction_lookup.claim_reduction.instance", "stage2.input.stage1.LookupOutput"] }, + Stage2ScalarExprPlan { symbol: "stage2.product_virtual.remainder.point.UniskipR0", kind: Stage2ScalarExprKind::PointElement { index: 0 }, operands: &["stage2.product_virtual.uniskip.sumcheck"] }, + Stage2ScalarExprPlan { symbol: "stage2.product_virtual.remainder.output.eq.Product", kind: Stage2ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage2.product_virtual.remainder.instance", "stage2.input.stage1.Product"] }, ]; pub const STAGE2_SUMCHECK_CLAIMS: &[Stage2SumcheckClaimPlan] = &[ Stage2SumcheckClaimPlan { symbol: "stage2.product_virtual.uniskip.input", stage: "stage2", domain: "jolt.stage2_uniskip_domain", num_rounds: 1, degree: 6, claim: "stage2.product_virtual.weighted_stage1_outputs", kernel: None, relation: Some(Stage2RelationKind::Stage2ProductVirtualUniskip), claim_value: "stage2.product_virtual.uniskip.claim_expr" }, @@ -244,6 +260,7 @@ pub const STAGE2_OPENING_EQUALITIES: &[Stage2OpeningClaimEqualityPlan] = &[]; pub const STAGE2_RELATION_OUTPUTS: &[Stage2RelationOutputPlan] = &[ Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2RamReadWrite, local_scalars: &[], expected_output: "stage2.ram_read_write.output.claim_expr" }, Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2InstructionLookupClaimReduction, local_scalars: &[], expected_output: "stage2.instruction_lookup.output.claim_expr" }, + Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2ProductVirtualRemainder, local_scalars: &[], expected_output: "stage2.product_virtual.remainder.output.claim_expr" }, ]; pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan { @@ -708,7 +725,17 @@ fn expected_batched_output_claim( )? } Stage2RelationKind::Stage2ProductVirtualRemainder => { - expected_product_remainder(store, evals, local_point)? + bolt_verifier_runtime::evaluate_relation_output_for_instance( + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + &store.0, + instance, + evals, + &[], + &[], + local_point, + )? } Stage2RelationKind::Stage2InstructionLookupClaimReduction => { bolt_verifier_runtime::evaluate_relation_output_for_instance( @@ -734,46 +761,6 @@ fn expected_batched_output_claim( Ok(expected) } -fn expected_product_remainder( - store: &Stage2ValueStore, - evals: &[Stage2NamedEval], - local_point: &[Fr], -) -> Result { - let tau_low = store.point("stage2.input.stage1.Product")?; - let tau_high = store.scalar("stage2.product_virtual.tau_high")?; - let r0 = *store - .point("stage2.product_virtual.uniskip.sumcheck")? - .first() - .ok_or(VerifyStage2Error::MissingValue { - symbol: "stage2.product_virtual.uniskip.sumcheck", - })?; - let r_tail = reverse_slice(local_point); - let low = EqPolynomial::::mle(tau_low, &r_tail); - let high = lagrange_kernel_eval( - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START, - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE, - tau_high, - r0, - ); - let weights = lagrange_evals( - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_START, - PRODUCT_VIRTUAL_UNISKIP_DOMAIN_SIZE, - r0, - ); - let left = weights[0] - * eval_by_name(evals, "stage2.product_virtual.remainder.eval.LeftInstructionInput")? - + weights[1] * eval_by_name(evals, "stage2.product_virtual.remainder.eval.LookupOutput")? - + weights[2] * eval_by_name(evals, "stage2.product_virtual.remainder.eval.OpFlagJump")?; - let right = weights[0] - * eval_by_name(evals, "stage2.product_virtual.remainder.eval.RightInstructionInput")? - + weights[1] - * eval_by_name(evals, "stage2.product_virtual.remainder.eval.InstructionFlagBranch")? - + weights[2] - * (Fr::from_u64(1) - - eval_by_name(evals, "stage2.product_virtual.remainder.eval.NextIsNoop")?); - Ok(high * low * left * right) -} - fn expected_ram_raf( evals: &[Stage2NamedEval], local_point: &[Fr], From fc529632267feba73a11958f5c7121b3dc5766e3 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 04:12:28 -0600 Subject: [PATCH 135/171] refactor(bolt): share relation output batches --- crates/bolt-verifier-runtime/src/lib.rs | 39 +++++- .../src/protocols/jolt/emit/rust/stage3.rs | 5 +- .../src/protocols/jolt/emit/rust/stage4.rs | 5 +- .../src/protocols/jolt/emit/rust/stage5.rs | 97 +++++--------- .../src/protocols/jolt/emit/rust/stage6.rs | 123 +++++------------- .../src/protocols/jolt/emit/rust/stage7.rs | 5 +- crates/bolt/tests/commitment_ir.rs | 10 +- crates/jolt-verifier/src/stages/stage3.rs | 5 +- crates/jolt-verifier/src/stages/stage4.rs | 5 +- crates/jolt-verifier/src/stages/stage5.rs | 97 +++++--------- crates/jolt-verifier/src/stages/stage6.rs | 123 +++++------------- crates/jolt-verifier/src/stages/stage7.rs | 5 +- 12 files changed, 187 insertions(+), 332 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 75885aaeef..91cd645f6f 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -553,6 +553,27 @@ pub struct NamedPoint<'a, F: Field> { pub point: &'a [F], } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct RelationOutputInputs<'a, F: Field> { + pub scalars: Vec>, + pub points: Vec>, +} + +impl Default for RelationOutputInputs<'_, F> { + fn default() -> Self { + Self { + scalars: Vec::new(), + points: Vec::new(), + } + } +} + +impl RelationOutputInputs<'_, F> { + pub fn empty() -> Self { + Self::default() + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct NamedEvalFamilyPlan { pub symbol: &'static str, @@ -1340,7 +1361,7 @@ pub fn evaluate_relation_output_for_instance( ) } -pub fn expected_relation_output_batch( +pub fn evaluate_relation_output_batch( driver: &SumcheckDriverPlan, batches: &[SumcheckBatchPlan], claims: &[SumcheckClaimPlan], @@ -1352,7 +1373,16 @@ pub fn expected_relation_output_batch( evals: &[StageNamedEval], point: &[Fr], batching_coeffs: &[Fr], -) -> Result { + mut local_inputs: LocalInputs, +) -> Result +where + R: ProtocolRelation, + E: From, + LocalInputs: for<'a> FnMut( + &SumcheckInstanceResultPlan, + &'a [Fr], + ) -> Result, E>, +{ let batch = find_batch(batches, driver.symbol, driver.batch)?; let claims = batch_claims(claims, batch)?; let mut expected = Fr::from_u64(0); @@ -1371,6 +1401,7 @@ pub fn expected_relation_output_batch( expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; + let inputs = local_inputs(instance, local_point)?; let value = evaluate_relation_output_for_instance( relation_outputs, field_exprs, @@ -1378,8 +1409,8 @@ pub fn expected_relation_output_batch( store, instance, evals, - &[], - &[], + &inputs.scalars, + &inputs.points, local_point, )?; expected += *coefficient * value; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 3681b09b67..575acd3f9a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1776,7 +1776,7 @@ where store, transcript, |store, evals, point, batching_coeffs| { - Ok(bolt_verifier_runtime::expected_relation_output_batch( + bolt_verifier_runtime::evaluate_relation_output_batch( driver, program.batches, program.claims, @@ -1788,7 +1788,8 @@ where evals, point, batching_coeffs, - )?) + |_, _| Ok::<_, VerifyStage3Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + ) }, |store, verified| observe_stage3_sumcheck_output(program, store, verified), |driver, error| VerifyStage3Error::Sumcheck { driver, error }, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 6b21145962..9efa6dad5d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -2027,7 +2027,7 @@ where store, transcript, |store, evals, point, batching_coeffs| { - Ok(bolt_verifier_runtime::expected_relation_output_batch( + bolt_verifier_runtime::evaluate_relation_output_batch( driver, program.batches, program.claims, @@ -2039,7 +2039,8 @@ where evals, point, batching_coeffs, - )?) + |_, _| Ok::<_, VerifyStage4Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + ) }, |store, verified| observe_stage4_sumcheck_output(program, store, verified), |driver, error| VerifyStage4Error::Sumcheck { driver, error }, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index d543870114..0491fe488b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -925,7 +925,7 @@ impl Stage5CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ + "use bolt_verifier_runtime::find_plan;\n\ use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ @@ -2106,7 +2106,20 @@ where store, transcript, |store, evals, point, batching_coeffs| { - expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs) + bolt_verifier_runtime::evaluate_relation_output_batch( + driver, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + store, + evals, + point, + batching_coeffs, + stage5_relation_output_inputs, + ) }, |store, verified| observe_stage5_sumcheck_output(program, store, verified), |driver, error| VerifyStage5Error::Sumcheck { driver, error }, @@ -2164,73 +2177,21 @@ fn observe_stage5_sumcheck_output( ) } -fn expected_batched_output_claim( - program: &'static Stage5VerifierProgramPlan, - driver: &'static Stage5SumcheckDriverPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage5NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage5Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage5Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let Some(relation) = claim.relation else { - return Err(VerifyStage5Error::InvalidProof { - driver: driver.symbol, - reason: "missing claim relation", - }); - }; - let value = match relation { - Stage5RelationKind::Stage5InstructionReadRaf => { - let local_scalars = evaluate_stage5_instruction_read_raf_point_scalars( - &STAGE5_INSTRUCTION_READ_RAF_PLAN, - local_point, - )?; - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, - &local_scalars, - &[bolt_verifier_runtime::NamedPoint { symbol: STAGE5_INSTRUCTION_READ_RAF_PLAN.point, point: local_point }], - local_point, - )? - } - Stage5RelationKind::Stage5RamRaClaimReduction - | Stage5RelationKind::Stage5RegistersValEvaluation => { - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, &[], &[], local_point, - )? - } - relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }), - }; - expected += *coefficient * value; +fn stage5_relation_output_inputs<'a>( + instance: &Stage5SumcheckInstanceResultPlan, + local_point: &'a [Fr], +) -> Result, VerifyStage5Error> { + if instance.relation != Stage5RelationKind::Stage5InstructionReadRaf { + return Ok(bolt_verifier_runtime::RelationOutputInputs::empty()); } - Ok(expected) + + Ok(bolt_verifier_runtime::RelationOutputInputs { + scalars: evaluate_stage5_instruction_read_raf_point_scalars( + &STAGE5_INSTRUCTION_READ_RAF_PLAN, + local_point, + )?, + points: Vec::new(), + }) } "# diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 29a4c33adf..e0c884f057 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -949,7 +949,7 @@ impl Stage6CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{batch_claims, find_batch, find_plan};\n\ + "use bolt_verifier_runtime::find_plan;\n\ use super::jolt_relations::{evaluate_stage67_bytecode_read_raf_output_scalars, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ @@ -2238,14 +2238,21 @@ where store, transcript, |store, evals, point, batching_coeffs| { - expected_batched_output_claim( - program, + bolt_verifier_runtime::evaluate_relation_output_batch( driver, - verifier_data, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, store, evals, point, batching_coeffs, + |instance, local_point| { + stage6_relation_output_inputs(program, verifier_data, store, instance, local_point) + }, ) }, |store, verified| observe_stage6_sumcheck_output(program, store, verified), @@ -2303,96 +2310,34 @@ fn observe_stage6_sumcheck_output( ) } -fn expected_batched_output_claim( +fn stage6_relation_output_inputs<'a>( program: &'static Stage6VerifierProgramPlan, - driver: &'static Stage6SumcheckDriverPlan, verifier_data: Option<&Stage6VerifierData>, store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage6Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage6Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let Some(relation) = claim.relation else { - return Err(VerifyStage6Error::InvalidProof { - driver: driver.symbol, - reason: "missing claim relation", - }); - }; - let value = match relation { - Stage6RelationKind::Stage6BytecodeReadRaf => { - let data = verifier_data - .and_then(|data| data.bytecode_read_raf.as_ref()) - .ok_or(VerifyStage6Error::MissingValue { - symbol: "stage6.bytecode_read_raf.data", - })?; - let log_t = stage6_trace_rounds(program)?; - let local_scalars = evaluate_stage67_bytecode_read_raf_output_scalars( - &STAGE6_BYTECODE_PLAN, - &data.entries, - data.entry_bytecode_index, - data.num_lookup_tables, - store, - local_point, - log_t, - )?; - expected_plan_relation_output(program, instance, store, evals, &local_scalars, local_point)? - } - Stage6RelationKind::Stage6Booleanity - | Stage6RelationKind::Stage6HammingBooleanity - | Stage6RelationKind::Stage6RamRaVirtual - | Stage6RelationKind::Stage6InstructionRaVirtual - | Stage6RelationKind::Stage6IncClaimReduction => expected_plan_relation_output( - program, - instance, - store, - evals, - &[], - local_point, - )?, - relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }), - }; - expected += *coefficient * value; + instance: &Stage6SumcheckInstanceResultPlan, + local_point: &'a [Fr], +) -> Result, VerifyStage6Error> { + if instance.relation != Stage6RelationKind::Stage6BytecodeReadRaf { + return Ok(bolt_verifier_runtime::RelationOutputInputs::empty()); } - Ok(expected) -} -fn expected_plan_relation_output( - program: &'static Stage6VerifierProgramPlan, - instance: &'static Stage6SumcheckInstanceResultPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_scalars: &[bolt_verifier_runtime::NamedScalar], - local_point: &[Fr], -) -> Result { - Ok(bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, - local_scalars, - &[], local_point, - )?) + let data = verifier_data + .and_then(|data| data.bytecode_read_raf.as_ref()) + .ok_or(VerifyStage6Error::MissingValue { + symbol: "stage6.bytecode_read_raf.data", + })?; + Ok(bolt_verifier_runtime::RelationOutputInputs { + scalars: evaluate_stage67_bytecode_read_raf_output_scalars( + &STAGE6_BYTECODE_PLAN, + &data.entries, + data.entry_bytecode_index, + data.num_lookup_tables, + store, + local_point, + stage6_trace_rounds(program)?, + )?, + points: Vec::new(), + }) } fn stage6_trace_rounds( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 7bc12bc5dc..fa765a470e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -2253,7 +2253,7 @@ where store, transcript, |store, evals, point, batching_coeffs| { - Ok(bolt_verifier_runtime::expected_relation_output_batch( + bolt_verifier_runtime::evaluate_relation_output_batch( driver, program.batches, program.claims, @@ -2265,7 +2265,8 @@ where evals, point, batching_coeffs, - )?) + |_, _| Ok::<_, VerifyStage7Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + ) }, |store, verified| observe_stage7_sumcheck_output(program, store, verified), |driver, error| VerifyStage7Error::Sumcheck { driver, error }, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 69b3e37239..39117b4635 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1492,7 +1492,10 @@ fn stage5_rust_targets_extract_and_compile() { .contains("stage5.registers_val_evaluation.output.lt.RegistersValCycle")); assert!(verifier_source .source - .contains("bolt_verifier_runtime::evaluate_relation_output_for_instance")); + .contains("bolt_verifier_runtime::evaluate_relation_output_batch")); + assert!(verifier_source + .source + .contains("stage5_relation_output_inputs")); assert!(verifier_source .source .contains("Stage5RelationKind::Stage5RamRaClaimReduction")); @@ -1889,7 +1892,10 @@ fn stage6_rust_targets_extract_and_compile() { .contains("expected_hamming_booleanity")); assert!(verifier_source .source - .contains("expected_plan_relation_output")); + .contains("bolt_verifier_runtime::evaluate_relation_output_batch")); + assert!(verifier_source + .source + .contains("stage6_relation_output_inputs")); assert!(verifier_source .source .contains("stage6.booleanity.output.eq.InstructionRa0")); diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 7665d860cf..d1656a437c 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -391,7 +391,7 @@ where store, transcript, |store, evals, point, batching_coeffs| { - Ok(bolt_verifier_runtime::expected_relation_output_batch( + bolt_verifier_runtime::evaluate_relation_output_batch( driver, program.batches, program.claims, @@ -403,7 +403,8 @@ where evals, point, batching_coeffs, - )?) + |_, _| Ok::<_, VerifyStage3Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + ) }, |store, verified| observe_stage3_sumcheck_output(program, store, verified), |driver, error| VerifyStage3Error::Sumcheck { driver, error }, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 87d15df945..2fdb7a647e 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -369,7 +369,7 @@ where store, transcript, |store, evals, point, batching_coeffs| { - Ok(bolt_verifier_runtime::expected_relation_output_batch( + bolt_verifier_runtime::evaluate_relation_output_batch( driver, program.batches, program.claims, @@ -381,7 +381,8 @@ where evals, point, batching_coeffs, - )?) + |_, _| Ok::<_, VerifyStage4Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + ) }, |store, verified| observe_stage4_sumcheck_output(program, store, verified), |driver, error| VerifyStage4Error::Sumcheck { driver, error }, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 438db0b00e..959712e76c 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; +use bolt_verifier_runtime::find_plan; use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; @@ -602,7 +602,20 @@ where store, transcript, |store, evals, point, batching_coeffs| { - expected_batched_output_claim(program, driver, store, evals, point, batching_coeffs) + bolt_verifier_runtime::evaluate_relation_output_batch( + driver, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + store, + evals, + point, + batching_coeffs, + stage5_relation_output_inputs, + ) }, |store, verified| observe_stage5_sumcheck_output(program, store, verified), |driver, error| VerifyStage5Error::Sumcheck { driver, error }, @@ -660,71 +673,19 @@ fn observe_stage5_sumcheck_output( ) } -fn expected_batched_output_claim( - program: &'static Stage5VerifierProgramPlan, - driver: &'static Stage5SumcheckDriverPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage5NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage5Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage5Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let Some(relation) = claim.relation else { - return Err(VerifyStage5Error::InvalidProof { - driver: driver.symbol, - reason: "missing claim relation", - }); - }; - let value = match relation { - Stage5RelationKind::Stage5InstructionReadRaf => { - let local_scalars = evaluate_stage5_instruction_read_raf_point_scalars( - &STAGE5_INSTRUCTION_READ_RAF_PLAN, - local_point, - )?; - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, - &local_scalars, - &[bolt_verifier_runtime::NamedPoint { symbol: STAGE5_INSTRUCTION_READ_RAF_PLAN.point, point: local_point }], - local_point, - )? - } - Stage5RelationKind::Stage5RamRaClaimReduction - | Stage5RelationKind::Stage5RegistersValEvaluation => { - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, &[], &[], local_point, - )? - } - relation => return Err(VerifyStage5Error::UnsupportedRelation { relation }), - }; - expected += *coefficient * value; +fn stage5_relation_output_inputs<'a>( + instance: &Stage5SumcheckInstanceResultPlan, + local_point: &'a [Fr], +) -> Result, VerifyStage5Error> { + if instance.relation != Stage5RelationKind::Stage5InstructionReadRaf { + return Ok(bolt_verifier_runtime::RelationOutputInputs::empty()); } - Ok(expected) + + Ok(bolt_verifier_runtime::RelationOutputInputs { + scalars: evaluate_stage5_instruction_read_raf_point_scalars( + &STAGE5_INSTRUCTION_READ_RAF_PLAN, + local_point, + )?, + points: Vec::new(), + }) } diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 3ffb24191d..f514b42ddb 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -1,6 +1,6 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{batch_claims, find_batch, find_plan}; +use bolt_verifier_runtime::find_plan; use super::jolt_relations::{evaluate_stage67_bytecode_read_raf_output_scalars, normalize_bytecode_read_raf_point, stage67_trace_rounds, Stage67BytecodeEntry, Stage67BytecodeFlag, Stage67BytecodeOutputTermPlan, Stage67BytecodeReadRafPlan, Stage67BytecodeRegister, Stage67BytecodeRegisterSymbols, Stage67BytecodeStagePlan, Stage67BytecodeTermPlan, Stage67RelationSymbols}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; @@ -872,14 +872,21 @@ where store, transcript, |store, evals, point, batching_coeffs| { - expected_batched_output_claim( - program, + bolt_verifier_runtime::evaluate_relation_output_batch( driver, - verifier_data, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, store, evals, point, batching_coeffs, + |instance, local_point| { + stage6_relation_output_inputs(program, verifier_data, store, instance, local_point) + }, ) }, |store, verified| observe_stage6_sumcheck_output(program, store, verified), @@ -937,96 +944,34 @@ fn observe_stage6_sumcheck_output( ) } -fn expected_batched_output_claim( +fn stage6_relation_output_inputs<'a>( program: &'static Stage6VerifierProgramPlan, - driver: &'static Stage6SumcheckDriverPlan, verifier_data: Option<&Stage6VerifierData>, store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage6Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage6Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let Some(relation) = claim.relation else { - return Err(VerifyStage6Error::InvalidProof { - driver: driver.symbol, - reason: "missing claim relation", - }); - }; - let value = match relation { - Stage6RelationKind::Stage6BytecodeReadRaf => { - let data = verifier_data - .and_then(|data| data.bytecode_read_raf.as_ref()) - .ok_or(VerifyStage6Error::MissingValue { - symbol: "stage6.bytecode_read_raf.data", - })?; - let log_t = stage6_trace_rounds(program)?; - let local_scalars = evaluate_stage67_bytecode_read_raf_output_scalars( - &STAGE6_BYTECODE_PLAN, - &data.entries, - data.entry_bytecode_index, - data.num_lookup_tables, - store, - local_point, - log_t, - )?; - expected_plan_relation_output(program, instance, store, evals, &local_scalars, local_point)? - } - Stage6RelationKind::Stage6Booleanity - | Stage6RelationKind::Stage6HammingBooleanity - | Stage6RelationKind::Stage6RamRaVirtual - | Stage6RelationKind::Stage6InstructionRaVirtual - | Stage6RelationKind::Stage6IncClaimReduction => expected_plan_relation_output( - program, - instance, - store, - evals, - &[], - local_point, - )?, - relation => return Err(VerifyStage6Error::UnsupportedRelation { relation }), - }; - expected += *coefficient * value; + instance: &Stage6SumcheckInstanceResultPlan, + local_point: &'a [Fr], +) -> Result, VerifyStage6Error> { + if instance.relation != Stage6RelationKind::Stage6BytecodeReadRaf { + return Ok(bolt_verifier_runtime::RelationOutputInputs::empty()); } - Ok(expected) -} -fn expected_plan_relation_output( - program: &'static Stage6VerifierProgramPlan, - instance: &'static Stage6SumcheckInstanceResultPlan, - store: &bolt_verifier_runtime::ValueStore, - evals: &[Stage6NamedEval], - local_scalars: &[bolt_verifier_runtime::NamedScalar], - local_point: &[Fr], -) -> Result { - Ok(bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - store, - instance, - evals, - local_scalars, - &[], local_point, - )?) + let data = verifier_data + .and_then(|data| data.bytecode_read_raf.as_ref()) + .ok_or(VerifyStage6Error::MissingValue { + symbol: "stage6.bytecode_read_raf.data", + })?; + Ok(bolt_verifier_runtime::RelationOutputInputs { + scalars: evaluate_stage67_bytecode_read_raf_output_scalars( + &STAGE6_BYTECODE_PLAN, + &data.entries, + data.entry_bytecode_index, + data.num_lookup_tables, + store, + local_point, + stage6_trace_rounds(program)?, + )?, + points: Vec::new(), + }) } fn stage6_trace_rounds( diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 20aea04f37..ccdc1e17d1 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -473,7 +473,7 @@ where store, transcript, |store, evals, point, batching_coeffs| { - Ok(bolt_verifier_runtime::expected_relation_output_batch( + bolt_verifier_runtime::evaluate_relation_output_batch( driver, program.batches, program.claims, @@ -485,7 +485,8 @@ where evals, point, batching_coeffs, - )?) + |_, _| Ok::<_, VerifyStage7Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + ) }, |store, verified| observe_stage7_sumcheck_output(program, store, verified), |driver, error| VerifyStage7Error::Sumcheck { driver, error }, From 3d94f7f77dd3b6439cbfa5560c6700b5f82d187d Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 04:23:50 -0600 Subject: [PATCH 136/171] refactor(bolt): type stage2 ram outputs --- .../src/protocols/jolt/emit/rust/stage2.rs | 202 ++++++++++-------- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../src/protocols/jolt/emit/rust/stage6.rs | 2 +- .../bolt/src/protocols/jolt/verifier_plan.rs | 2 +- .../src/protocols/jolt/verifier_values.rs | 2 +- crates/jolt-verifier/src/stages/stage2.rs | 162 +++++++------- 6 files changed, 188 insertions(+), 184 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index d20eb380b0..66a14ddb4a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -399,6 +399,28 @@ fn stage2_relation_output_plans() -> Stage2RelationOutputRows { "stage2.product_virtual.remainder.output.right.weighted_expr", ], ), + stage2_field_expr( + "stage2.ram_raf.output.claim_expr", + "field.mul", + ["stage2.ram_raf.output.unmap", "stage2.ram_raf.eval.RamRa"], + ), + stage2_field_expr( + "stage2.ram_output.output.partial.ValFinalMinusIo", + "field.sub", + [ + "stage2.ram_output.eval.RamValFinal", + "stage2.ram_output.output.val_io", + ], + ), + stage2_field_expr( + "stage2.ram_output.output.claim_expr", + "field.product", + [ + "stage2.ram_output.output.eq", + "stage2.ram_output.output.io_mask", + "stage2.ram_output.output.partial.ValFinalMinusIo", + ], + ), ], relation_outputs: vec![ Stage2RelationOutputPlan { @@ -416,6 +438,20 @@ fn stage2_relation_output_plans() -> Stage2RelationOutputRows { local_scalars: Vec::new(), expected_output: "stage2.product_virtual.remainder.output.claim_expr".to_owned(), }, + Stage2RelationOutputPlan { + relation: "jolt.stage2.ram.raf_evaluation".to_owned(), + local_scalars: vec!["stage2.ram_raf.output.unmap".to_owned()], + expected_output: "stage2.ram_raf.output.claim_expr".to_owned(), + }, + Stage2RelationOutputPlan { + relation: "jolt.stage2.ram.output_check".to_owned(), + local_scalars: vec![ + "stage2.ram_output.output.eq".to_owned(), + "stage2.ram_output.output.io_mask".to_owned(), + "stage2.ram_output.output.val_io".to_owned(), + ], + expected_output: "stage2.ram_output.output.claim_expr".to_owned(), + }, ], } } @@ -990,6 +1026,11 @@ impl Stage2CpuProgram { )); values.extend(symbols(self.field_exprs.iter().map(|expr| &expr.symbol))); values.extend(symbols(self.scalar_exprs.iter().map(|expr| &expr.symbol))); + values.extend(symbols( + self.relation_outputs + .iter() + .flat_map(|output| output.local_scalars.iter()), + )); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); values } @@ -1019,6 +1060,12 @@ impl Stage2CpuProgram { self.scalar_exprs.iter().map(|expr| &expr.symbol), verifier_values::VerifierScalarSourceKind::ScalarExpr, ); + values.extend( + self.relation_outputs + .iter() + .flat_map(|output| output.local_scalars.iter()), + verifier_values::VerifierScalarSourceKind::RelationOutputLocal, + ); values.extend( self.evals.iter().map(|eval| &eval.symbol), verifier_values::VerifierScalarSourceKind::SumcheckEval, @@ -1439,9 +1486,9 @@ impl Stage2CpuProgram { } fn emit_verifier_imports() -> &'static str { - "use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice};\n\ + "use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, find_batch, find_plan, reverse_slice};\n\ use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt};\n\ - use jolt_poly::{EqPolynomial, UnivariatePoly};\n\ + use jolt_poly::UnivariatePoly;\n\ use jolt_sumcheck::{CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier};\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" } @@ -2501,8 +2548,20 @@ where reason: "batched point mismatch", }); } - let expected = - expected_batched_output_claim(program, driver, &*store, &proof.evals, &output.point, &batching_coeffs, ram)?; + let expected = bolt_verifier_runtime::evaluate_relation_output_batch( + driver, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + &store.0, + &proof.evals, + &output.point, + &batching_coeffs, + |instance, local_point| stage2_relation_output_inputs(&*store, ram, instance, local_point), + )?; if output.value != expected { return Err(VerifyStage2Error::InvalidProof { driver: driver.symbol, @@ -2658,104 +2717,42 @@ impl Stage2ValueStore { } } -fn expected_batched_output_claim( - program: &'static Stage2VerifierProgramPlan, - driver: &'static Stage2SumcheckDriverPlan, +fn stage2_relation_output_inputs<'a>( store: &Stage2ValueStore, - evals: &[Stage2NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], ram: Option<&Stage2RamData<'_>>, -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage2Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage2Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let value = match instance.relation { - Stage2RelationKind::Stage2RamReadWrite => { - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - &store.0, - instance, - evals, - &[], - &[], - local_point, - )? - } - Stage2RelationKind::Stage2ProductVirtualRemainder => { - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - &store.0, - instance, - evals, - &[], - &[], - local_point, - )? - } - Stage2RelationKind::Stage2InstructionLookupClaimReduction => { - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - &store.0, - instance, - evals, - &[], - &[], - local_point, - )? - } - Stage2RelationKind::Stage2RamRafEvaluation => expected_ram_raf(evals, local_point, ram)?, - Stage2RelationKind::Stage2RamOutputCheck => { - expected_ram_output(store, evals, local_point, ram)? - } - relation => return Err(VerifyStage2Error::UnsupportedRelation { relation }), - }; - expected += *coefficient * value; - } - Ok(expected) + instance: &Stage2SumcheckInstanceResultPlan, + local_point: &'a [Fr], +) -> Result, VerifyStage2Error> { + let scalars = match instance.relation { + Stage2RelationKind::Stage2RamRafEvaluation => stage2_ram_raf_output_scalars(local_point, ram)?, + Stage2RelationKind::Stage2RamOutputCheck => stage2_ram_output_scalars(store, local_point, ram)?, + _ => Vec::new(), + }; + Ok(bolt_verifier_runtime::RelationOutputInputs { + scalars, + points: Vec::new(), + }) } -fn expected_ram_raf( - evals: &[Stage2NamedEval], +fn stage2_ram_raf_output_scalars( local_point: &[Fr], ram: Option<&Stage2RamData<'_>>, -) -> Result { +) -> Result>, VerifyStage2Error> { let ram = ram.ok_or(VerifyStage2Error::MissingRam { context: "stage2.ram.raf_evaluation", })?; let address = reverse_slice(local_point); - let unmap = unmap_eval(ram.log_k, ram.start_address, &address); - Ok(unmap * eval_by_name(evals, "stage2.ram_raf.eval.RamRa")?) + Ok(vec![bolt_verifier_runtime::NamedScalar { + symbol: "stage2.ram_raf.output.unmap", + value: unmap_eval(ram.log_k, ram.start_address, &address), + }]) } -fn expected_ram_output( +fn stage2_ram_output_scalars( store: &Stage2ValueStore, - evals: &[Stage2NamedEval], local_point: &[Fr], ram: Option<&Stage2RamData<'_>>, -) -> Result { +) -> Result>, VerifyStage2Error> { let ram = ram.ok_or(VerifyStage2Error::MissingRam { context: "stage2.ram.output_check", })?; @@ -2764,7 +2761,14 @@ fn expected_ram_output( })?; let r_address = store.point("stage2.ram_output.r_address")?; let opening_point = reverse_slice(local_point); - let eq_eval = EqPolynomial::::mle(r_address, &opening_point); + if r_address.len() != opening_point.len() { + return Err(VerifyStage2Error::InvalidInputLength { + input: "stage2.ram_output.r_address", + expected: opening_point.len(), + actual: r_address.len(), + }); + } + let eq_eval = eq_eval(r_address, &opening_point); let io_mask = range_mask_eval(layout.io_start, layout.io_end, &opening_point); let val_io = sparse_final_ram_eval( ram.final_ram, @@ -2772,8 +2776,26 @@ fn expected_ram_output( layout.io_end, &opening_point, ); - let val_final = eval_by_name(evals, "stage2.ram_output.eval.RamValFinal")?; - Ok(eq_eval * io_mask * (val_final - val_io)) + Ok(vec![ + bolt_verifier_runtime::NamedScalar { + symbol: "stage2.ram_output.output.eq", + value: eq_eval, + }, + bolt_verifier_runtime::NamedScalar { + symbol: "stage2.ram_output.output.io_mask", + value: io_mask, + }, + bolt_verifier_runtime::NamedScalar { + symbol: "stage2.ram_output.output.val_io", + value: val_io, + }, + ]) +} + +fn eq_eval(lhs: &[Fr], rhs: &[Fr]) -> Fr { + lhs.iter().zip(rhs).fold(Fr::from_u64(1), |acc, (lhs, rhs)| { + acc * (*lhs * *rhs + (Fr::from_u64(1) - *lhs) * (Fr::from_u64(1) - *rhs)) + }) } fn driver_evals( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 0491fe488b..0bb1cf7156 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -546,7 +546,7 @@ impl Stage5CpuProgram { self.relation_outputs .iter() .flat_map(|claim| claim.local_scalars.iter()), - verifier_values::VerifierScalarSourceKind::PointDerived, + verifier_values::VerifierScalarSourceKind::RelationOutputLocal, ); values.extend( self.evals.iter().map(|eval| &eval.symbol), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index e0c884f057..ab682fc7f9 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -572,7 +572,7 @@ impl Stage6CpuProgram { self.relation_outputs .iter() .flat_map(|claim| claim.local_scalars.iter()), - verifier_values::VerifierScalarSourceKind::PointDerived, + verifier_values::VerifierScalarSourceKind::RelationOutputLocal, ); values.extend( self.evals.iter().map(|eval| &eval.symbol), diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 50380061d4..fb8392b158 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -356,7 +356,7 @@ impl VerifierStagePlan { self.relation_outputs .iter() .flat_map(|claim| claim.local_scalars.iter()), - VerifierScalarSourceKind::PointDerived, + VerifierScalarSourceKind::RelationOutputLocal, ); values.extend( self.sumcheck_evals.iter().map(|eval| &eval.symbol), diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 90da83c540..b256ec9993 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -9,7 +9,7 @@ pub enum VerifierScalarSourceKind { TranscriptScalar, FieldExpr, ScalarExpr, - PointDerived, + RelationOutputLocal, SumcheckEval, OutputEvalFamily, OutputProductFamily, diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index 6af2e76b0a..fcd21cdfd3 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -1,8 +1,8 @@ #![allow(dead_code)] -use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, eval_by_name, find_batch, find_plan, reverse_slice}; +use bolt_verifier_runtime::{append_labeled_scalar, batch_claims, find_batch, find_plan, reverse_slice}; use jolt_field::{Field, Fr, MulPow2, MulPrimitiveInt}; -use jolt_poly::{EqPolynomial, UnivariatePoly}; +use jolt_poly::UnivariatePoly; use jolt_sumcheck::{CompressedLabeledRoundPoly, SumcheckClaim, SumcheckError, SumcheckVerifier}; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -164,6 +164,9 @@ pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[ Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.right.NextIsNoop", kind: Stage2FieldExprKind::Mul, operands: &["stage2.product_virtual.remainder.output.weight.ShouldJump", "stage2.product_virtual.remainder.output.partial.NotNextIsNoop"] }, Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.right.weighted_expr", kind: Stage2FieldExprKind::Sum, operands: &["stage2.product_virtual.remainder.output.right.RightInstructionInput", "stage2.product_virtual.remainder.output.right.InstructionFlagBranch", "stage2.product_virtual.remainder.output.right.NextIsNoop"] }, Stage2FieldExprPlan { symbol: "stage2.product_virtual.remainder.output.claim_expr", kind: Stage2FieldExprKind::Product, operands: &["stage2.product_virtual.remainder.output.high", "stage2.product_virtual.remainder.output.eq.Product", "stage2.product_virtual.remainder.output.left.weighted_expr", "stage2.product_virtual.remainder.output.right.weighted_expr"] }, + Stage2FieldExprPlan { symbol: "stage2.ram_raf.output.claim_expr", kind: Stage2FieldExprKind::Mul, operands: &["stage2.ram_raf.output.unmap", "stage2.ram_raf.eval.RamRa"] }, + Stage2FieldExprPlan { symbol: "stage2.ram_output.output.partial.ValFinalMinusIo", kind: Stage2FieldExprKind::Sub, operands: &["stage2.ram_output.eval.RamValFinal", "stage2.ram_output.output.val_io"] }, + Stage2FieldExprPlan { symbol: "stage2.ram_output.output.claim_expr", kind: Stage2FieldExprKind::Product, operands: &["stage2.ram_output.output.eq", "stage2.ram_output.output.io_mask", "stage2.ram_output.output.partial.ValFinalMinusIo"] }, ]; pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[ Stage2ScalarExprPlan { symbol: "stage2.ram_read_write.output.eq.Cycle", kind: Stage2ScalarExprKind::StructuredPolynomial { polynomial: bolt_verifier_runtime::StructuredPolynomialKind::Eq, x_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Prefix, length: bolt_verifier_runtime::StructuredPolynomialPointLength::YPoint, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::Reverse }, y_point: bolt_verifier_runtime::StructuredPolynomialPointTransform { segment: bolt_verifier_runtime::StructuredPolynomialPointSegment::Full, length: bolt_verifier_runtime::StructuredPolynomialPointLength::Full, order: bolt_verifier_runtime::StructuredPolynomialPointOrder::AsIs } }, operands: &["stage2.ram_read_write.instance", "stage2.input.stage1.RamReadValue"] }, @@ -257,10 +260,14 @@ pub const STAGE2_OPENING_BATCHES: &[Stage2OpeningBatchPlan] = &[ Stage2OpeningBatchPlan { symbol: "stage2.openings", stage: "stage2", proof_slot: "stage2.openings", policy: "jolt_stage2_output_order", count: 18, ordered_claims: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"], claim_operands: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"] }, ]; pub const STAGE2_OPENING_EQUALITIES: &[Stage2OpeningClaimEqualityPlan] = &[]; +pub const STAGE2_RELATION_OUTPUT_3_LOCAL_SCALARS: &[&str] = &["stage2.ram_raf.output.unmap"]; +pub const STAGE2_RELATION_OUTPUT_4_LOCAL_SCALARS: &[&str] = &["stage2.ram_output.output.eq", "stage2.ram_output.output.io_mask", "stage2.ram_output.output.val_io"]; pub const STAGE2_RELATION_OUTPUTS: &[Stage2RelationOutputPlan] = &[ Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2RamReadWrite, local_scalars: &[], expected_output: "stage2.ram_read_write.output.claim_expr" }, Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2InstructionLookupClaimReduction, local_scalars: &[], expected_output: "stage2.instruction_lookup.output.claim_expr" }, Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2ProductVirtualRemainder, local_scalars: &[], expected_output: "stage2.product_virtual.remainder.output.claim_expr" }, + Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2RamRafEvaluation, local_scalars: STAGE2_RELATION_OUTPUT_3_LOCAL_SCALARS, expected_output: "stage2.ram_raf.output.claim_expr" }, + Stage2RelationOutputPlan { relation: Stage2RelationKind::Stage2RamOutputCheck, local_scalars: STAGE2_RELATION_OUTPUT_4_LOCAL_SCALARS, expected_output: "stage2.ram_output.output.claim_expr" }, ]; pub const STAGE2_PROGRAM: Stage2VerifierProgramPlan = Stage2VerifierProgramPlan { @@ -525,8 +532,20 @@ where reason: "batched point mismatch", }); } - let expected = - expected_batched_output_claim(program, driver, &*store, &proof.evals, &output.point, &batching_coeffs, ram)?; + let expected = bolt_verifier_runtime::evaluate_relation_output_batch( + driver, + program.batches, + program.claims, + program.instance_results, + program.relation_outputs, + program.field_exprs, + program.scalar_exprs, + &store.0, + &proof.evals, + &output.point, + &batching_coeffs, + |instance, local_point| stage2_relation_output_inputs(&*store, ram, instance, local_point), + )?; if output.value != expected { return Err(VerifyStage2Error::InvalidProof { driver: driver.symbol, @@ -682,104 +701,42 @@ impl Stage2ValueStore { } } -fn expected_batched_output_claim( - program: &'static Stage2VerifierProgramPlan, - driver: &'static Stage2SumcheckDriverPlan, +fn stage2_relation_output_inputs<'a>( store: &Stage2ValueStore, - evals: &[Stage2NamedEval], - point: &[Fr], - batching_coeffs: &[Fr], ram: Option<&Stage2RamData<'_>>, -) -> Result { - let batch = find_batch(program.batches, driver.symbol, driver.batch)?; - let claims = batch_claims(program.claims, batch)?; - let mut expected = Fr::from_u64(0); - for (claim, coefficient) in claims.iter().zip(batching_coeffs) { - let instance = program - .instance_results - .iter() - .find(|instance| instance.claim == claim.symbol && instance.source == driver.symbol) - .ok_or(VerifyStage2Error::MissingClaim { - batch: batch.symbol, - claim: claim.symbol, - })?; - let local_point = point - .get(instance.round_offset..instance.round_offset + instance.num_rounds) - .ok_or(VerifyStage2Error::InvalidInputLength { - input: instance.symbol, - expected: instance.round_offset + instance.num_rounds, - actual: point.len(), - })?; - let value = match instance.relation { - Stage2RelationKind::Stage2RamReadWrite => { - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - &store.0, - instance, - evals, - &[], - &[], - local_point, - )? - } - Stage2RelationKind::Stage2ProductVirtualRemainder => { - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - &store.0, - instance, - evals, - &[], - &[], - local_point, - )? - } - Stage2RelationKind::Stage2InstructionLookupClaimReduction => { - bolt_verifier_runtime::evaluate_relation_output_for_instance( - program.relation_outputs, - program.field_exprs, - program.scalar_exprs, - &store.0, - instance, - evals, - &[], - &[], - local_point, - )? - } - Stage2RelationKind::Stage2RamRafEvaluation => expected_ram_raf(evals, local_point, ram)?, - Stage2RelationKind::Stage2RamOutputCheck => { - expected_ram_output(store, evals, local_point, ram)? - } - relation => return Err(VerifyStage2Error::UnsupportedRelation { relation }), - }; - expected += *coefficient * value; - } - Ok(expected) + instance: &Stage2SumcheckInstanceResultPlan, + local_point: &'a [Fr], +) -> Result, VerifyStage2Error> { + let scalars = match instance.relation { + Stage2RelationKind::Stage2RamRafEvaluation => stage2_ram_raf_output_scalars(local_point, ram)?, + Stage2RelationKind::Stage2RamOutputCheck => stage2_ram_output_scalars(store, local_point, ram)?, + _ => Vec::new(), + }; + Ok(bolt_verifier_runtime::RelationOutputInputs { + scalars, + points: Vec::new(), + }) } -fn expected_ram_raf( - evals: &[Stage2NamedEval], +fn stage2_ram_raf_output_scalars( local_point: &[Fr], ram: Option<&Stage2RamData<'_>>, -) -> Result { +) -> Result>, VerifyStage2Error> { let ram = ram.ok_or(VerifyStage2Error::MissingRam { context: "stage2.ram.raf_evaluation", })?; let address = reverse_slice(local_point); - let unmap = unmap_eval(ram.log_k, ram.start_address, &address); - Ok(unmap * eval_by_name(evals, "stage2.ram_raf.eval.RamRa")?) + Ok(vec![bolt_verifier_runtime::NamedScalar { + symbol: "stage2.ram_raf.output.unmap", + value: unmap_eval(ram.log_k, ram.start_address, &address), + }]) } -fn expected_ram_output( +fn stage2_ram_output_scalars( store: &Stage2ValueStore, - evals: &[Stage2NamedEval], local_point: &[Fr], ram: Option<&Stage2RamData<'_>>, -) -> Result { +) -> Result>, VerifyStage2Error> { let ram = ram.ok_or(VerifyStage2Error::MissingRam { context: "stage2.ram.output_check", })?; @@ -788,7 +745,14 @@ fn expected_ram_output( })?; let r_address = store.point("stage2.ram_output.r_address")?; let opening_point = reverse_slice(local_point); - let eq_eval = EqPolynomial::::mle(r_address, &opening_point); + if r_address.len() != opening_point.len() { + return Err(VerifyStage2Error::InvalidInputLength { + input: "stage2.ram_output.r_address", + expected: opening_point.len(), + actual: r_address.len(), + }); + } + let eq_eval = eq_eval(r_address, &opening_point); let io_mask = range_mask_eval(layout.io_start, layout.io_end, &opening_point); let val_io = sparse_final_ram_eval( ram.final_ram, @@ -796,8 +760,26 @@ fn expected_ram_output( layout.io_end, &opening_point, ); - let val_final = eval_by_name(evals, "stage2.ram_output.eval.RamValFinal")?; - Ok(eq_eval * io_mask * (val_final - val_io)) + Ok(vec![ + bolt_verifier_runtime::NamedScalar { + symbol: "stage2.ram_output.output.eq", + value: eq_eval, + }, + bolt_verifier_runtime::NamedScalar { + symbol: "stage2.ram_output.output.io_mask", + value: io_mask, + }, + bolt_verifier_runtime::NamedScalar { + symbol: "stage2.ram_output.output.val_io", + value: val_io, + }, + ]) +} + +fn eq_eval(lhs: &[Fr], rhs: &[Fr]) -> Fr { + lhs.iter().zip(rhs).fold(Fr::from_u64(1), |acc, (lhs, rhs)| { + acc * (*lhs * *rhs + (Fr::from_u64(1) - *lhs) * (Fr::from_u64(1) - *rhs)) + }) } fn driver_evals( From efc9e3b6209ad9a91a80c277662ecf9cbca6fc0b Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 04:53:33 -0600 Subject: [PATCH 137/171] fix(equivalence): adapt stage2 verifier plan Wire generated Stage2 scalar expressions and relation-output rows through the equivalence adapter, map the new typed Stage2 expression tags, and refresh the checked-in Stage2 verifier artifact via the Bolt artifact writer. --- crates/bolt/tests/commitment_ir.rs | 2 +- crates/jolt-equivalence/src/plan_adapters.rs | 37 +++++++++++++++++++ .../src/plan_adapters/generated_stage2.rs | 4 +- crates/jolt-verifier/src/stages/stage2.rs | 5 ++- 4 files changed, 44 insertions(+), 4 deletions(-) diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index 39117b4635..f756b059b5 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -2179,7 +2179,7 @@ fn stage7_rust_targets_extract_and_compile() { .contains("stage7.hamming_weight_claim_reduction.output.term")); assert!(verifier_source .source - .contains("bolt_verifier_runtime::expected_relation_output_batch")); + .contains("bolt_verifier_runtime::evaluate_relation_output_batch")); assert!(verifier_source .source .contains("stage7.input.stage6.booleanity.InstructionRa_0")); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 11ef57f2e3..8f6c3e4052 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -345,6 +345,24 @@ fn generated_field_expr_kind(value: &str) -> bolt_verifier_runtime::FieldExprKin parts[2].parse::().expect("lagrange index is usize"), ) } + value if value.starts_with("poly.lagrange_kernel_eval:") => { + let spec = value + .strip_prefix("poly.lagrange_kernel_eval:") + .expect("lagrange kernel expression has prefix"); + let parts = spec.split(':').collect::>(); + assert!( + parts.len() == 2, + "lagrange kernel expression has two fields" + ); + bolt_verifier_runtime::FieldExprKind::LagrangeKernelEval( + parts[0] + .parse::() + .expect("lagrange kernel domain start is i64"), + parts[1] + .parse::() + .expect("lagrange kernel domain size is usize"), + ) + } value => panic!("unsupported generated field expression kind `{value}`"), } } @@ -358,6 +376,14 @@ fn generated_scalar_expr_kind(value: &str) -> bolt_verifier_runtime::ScalarExprK match value { "field_vector.sum" => bolt_verifier_runtime::ScalarExprKind::FieldVectorSum, "field_vector.product" => bolt_verifier_runtime::ScalarExprKind::FieldVectorProduct, + value if value.starts_with("point.element:") => { + let index = value + .strip_prefix("point.element:") + .expect("point element expression has prefix") + .parse::() + .expect("point element index is usize"); + bolt_verifier_runtime::ScalarExprKind::PointElement { index } + } value if value.starts_with("field.power_strided_weighted_sum:") => { let spec = value .strip_prefix("field.power_strided_weighted_sum:") @@ -588,6 +614,7 @@ macro_rules! define_stage_adapter_impl { $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? + $(, empty_opening_equalities = $empty_opening_equalities:ident)? ) => { pub fn $function(program: &$compiler) -> &'static $module::$program { Box::leak(Box::new($module::$program { @@ -877,6 +904,12 @@ macro_rules! define_stage_adapter_impl { .collect(), ), )? + $( + opening_equalities: { + let _ = stringify!($empty_opening_equalities); + &[] + }, + )? opening_batches: super::leak_slice( program .opening_batches @@ -1174,6 +1207,7 @@ macro_rules! define_stage_adapter_no_absorb { $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? + $(, empty_opening_equalities = $empty_opening_equalities:ident)? ) => { define_stage_adapter_impl!( generated, @@ -1202,6 +1236,7 @@ macro_rules! define_stage_adapter_no_absorb { $(, relation_outputs = $relation_output)? $(, empty_relation_outputs = $empty_relation_outputs)? $(, opening_equalities = $opening_equality)? + $(, empty_opening_equalities = $empty_opening_equalities)? ); }; ( @@ -1231,6 +1266,7 @@ macro_rules! define_stage_adapter_no_absorb { $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? + $(, empty_opening_equalities = $empty_opening_equalities:ident)? ) => { define_stage_adapter_impl!( kernel, @@ -1259,6 +1295,7 @@ macro_rules! define_stage_adapter_no_absorb { $(, relation_outputs = $relation_output)? $(, empty_relation_outputs = $empty_relation_outputs)? $(, opening_equalities = $opening_equality)? + $(, empty_opening_equalities = $empty_opening_equalities)? ); }; } diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs index c5426e57f4..6213a95a30 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage2.rs @@ -22,5 +22,7 @@ define_stage_adapter_no_absorb!( Stage2PointExprPlan, Stage2OpeningClaimPlan, Stage2OpeningBatchPlan, - empty_scalar_exprs = Stage2ScalarExprPlan + scalar_expr = Stage2ScalarExprPlan, + relation_outputs = Stage2RelationOutputPlan, + empty_opening_equalities = Stage2OpeningClaimEqualityPlan ); diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index fcd21cdfd3..5a59738bca 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -26,7 +26,8 @@ pub use bolt_verifier_runtime::{ FieldExprKind as Stage2FieldExprKind, FieldExprPlan as Stage2FieldExprPlan, OpeningClaimEqualityPlan as Stage2OpeningClaimEqualityPlan, - ScalarExprKind as Stage2ScalarExprKind, ScalarExprPlan as Stage2ScalarExprPlan, + ScalarExprPlan as Stage2ScalarExprPlan, + ScalarExprKind as Stage2ScalarExprKind, OpeningBatchPlan as Stage2OpeningBatchPlan, OpeningClaimPlan as Stage2OpeningClaimPlan, OpeningInputPlan as Stage2OpeningInputPlan, PointExprKind as Stage2PointExprKind, PointExprPlan as Stage2PointExprPlan, ProgramStepKind as Stage2ProgramStepKind, @@ -256,10 +257,10 @@ pub const STAGE2_OPENING_CLAIMS: &[Stage2OpeningClaimPlan] = &[ Stage2OpeningClaimPlan { symbol: "stage2.ram_output.opening.RamValFinal", oracle: "RamValFinal", domain: "jolt.ram_address_domain", point_arity: 16, claim_kind: Stage2ClaimKind::Virtual, point_source: "stage2.ram_output.instance", eval_source: "stage2.ram_output.eval.RamValFinal" }, ]; +pub const STAGE2_OPENING_EQUALITIES: &[Stage2OpeningClaimEqualityPlan] = &[]; pub const STAGE2_OPENING_BATCHES: &[Stage2OpeningBatchPlan] = &[ Stage2OpeningBatchPlan { symbol: "stage2.openings", stage: "stage2", proof_slot: "stage2.openings", policy: "jolt_stage2_output_order", count: 18, ordered_claims: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"], claim_operands: &["stage2.ram_read_write.opening.RamVal", "stage2.ram_read_write.opening.RamRa", "stage2.ram_read_write.opening.RamInc", "stage2.product_virtual.remainder.opening.LeftInstructionInput", "stage2.product_virtual.remainder.opening.RightInstructionInput", "stage2.product_virtual.remainder.opening.OpFlagJump", "stage2.product_virtual.remainder.opening.OpFlagWriteLookupOutputToRD", "stage2.product_virtual.remainder.opening.LookupOutput", "stage2.product_virtual.remainder.opening.InstructionFlagBranch", "stage2.product_virtual.remainder.opening.NextIsNoop", "stage2.product_virtual.remainder.opening.OpFlagVirtualInstruction", "stage2.instruction_lookup.claim_reduction.opening.LookupOutput", "stage2.instruction_lookup.claim_reduction.opening.LeftLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.RightLookupOperand", "stage2.instruction_lookup.claim_reduction.opening.LeftInstructionInput", "stage2.instruction_lookup.claim_reduction.opening.RightInstructionInput", "stage2.ram_raf.opening.RamRa", "stage2.ram_output.opening.RamValFinal"] }, ]; -pub const STAGE2_OPENING_EQUALITIES: &[Stage2OpeningClaimEqualityPlan] = &[]; pub const STAGE2_RELATION_OUTPUT_3_LOCAL_SCALARS: &[&str] = &["stage2.ram_raf.output.unmap"]; pub const STAGE2_RELATION_OUTPUT_4_LOCAL_SCALARS: &[&str] = &["stage2.ram_output.output.eq", "stage2.ram_output.output.io_mask", "stage2.ram_output.output.val_io"]; pub const STAGE2_RELATION_OUTPUTS: &[Stage2RelationOutputPlan] = &[ From d9d3de500bcbdf5adc18c182d20e446930de0ba0 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 06:37:20 -0600 Subject: [PATCH 138/171] fix(verifier): thread eval families through programs Make relation-output evaluation honor dependency availability instead of eagerly failing on sibling relation points or eval families that are not available for the selected output. Store typed eval-family rows on generated StageProgramPlan and have Stage 5/6 verifiers consume program.indexed_eval_families, so dynamically leaked verifier plans stay aligned with Markos/core-specific lookup-table counts. --- crates/bolt-verifier-runtime/src/lib.rs | 202 ++++++++++++++++-- .../src/protocols/jolt/emit/rust/stage2.rs | 1 + .../src/protocols/jolt/emit/rust/stage3.rs | 1 + .../src/protocols/jolt/emit/rust/stage4.rs | 7 + .../src/protocols/jolt/emit/rust/stage5.rs | 15 +- .../src/protocols/jolt/emit/rust/stage6.rs | 15 +- .../src/protocols/jolt/emit/rust/stage7.rs | 7 + crates/jolt-equivalence/src/plan_adapters.rs | 36 ++++ .../src/plan_adapters/generated_stage4.rs | 1 + .../src/plan_adapters/generated_stage5.rs | 1 + .../src/plan_adapters/generated_stage6.rs | 1 + .../src/plan_adapters/generated_stage7.rs | 1 + crates/jolt-verifier/src/stages/stage2.rs | 1 + crates/jolt-verifier/src/stages/stage3.rs | 1 + crates/jolt-verifier/src/stages/stage4.rs | 2 + crates/jolt-verifier/src/stages/stage5.rs | 4 +- crates/jolt-verifier/src/stages/stage6.rs | 4 +- crates/jolt-verifier/src/stages/stage7.rs | 2 + 18 files changed, 283 insertions(+), 19 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 91cd645f6f..57577e2faa 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -493,6 +493,7 @@ pub struct StageProgramPlan { pub drivers: &'static [SumcheckDriverPlan], pub instance_results: &'static [SumcheckInstanceResultPlan], pub evals: &'static [SumcheckEvalPlan], + pub indexed_eval_families: &'static [NamedEvalFamilyPlan], pub relation_outputs: &'static [RelationOutputPlan], pub point_exprs: &'static [PointExprPlan], pub opening_claims: &'static [OpeningClaimPlan], @@ -553,6 +554,12 @@ pub struct NamedPoint<'a, F: Field> { pub point: &'a [F], } +#[derive(Clone, Debug, PartialEq, Eq)] +struct NamedFieldVector { + symbol: &'static str, + values: Vec, +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputInputs<'a, F: Field> { pub scalars: Vec>, @@ -1294,10 +1301,27 @@ pub fn eval_family_values( .collect() } +pub fn try_eval_family_values( + evals: &[StageNamedEval], + family: &NamedEvalFamilyPlan, +) -> Option> { + family + .evals + .iter() + .map(|&name| { + evals + .iter() + .find(|eval| eval.name == name) + .map(|eval| eval.value) + }) + .collect() +} + pub fn evaluate_relation_output( plan: &RelationOutputPlan, field_exprs: &[FieldExprPlan], scalar_exprs: &[ScalarExprPlan], + eval_families: &[NamedEvalFamilyPlan], store: &ValueStore, instance_symbol: &'static str, evals: &[StageNamedEval], @@ -1317,10 +1341,20 @@ pub fn evaluate_relation_output( for eval in evals { scratch.insert(eval.name, eval.value); } + let local_field_vectors = eval_families + .iter() + .filter_map(|family| { + try_eval_family_values(evals, family).map(|values| NamedFieldVector { + symbol: family.symbol, + values, + }) + }) + .collect::>(); let context = RelationOutputContext { instance_symbol, local_points, local_point, + local_field_vectors: &local_field_vectors, }; evaluate_available_exprs_with_scratch(field_exprs, scalar_exprs, store, &mut scratch, context)?; scratch @@ -1334,6 +1368,7 @@ pub fn evaluate_relation_output_for_instance( relation_outputs: &[RelationOutputPlan], field_exprs: &[FieldExprPlan], scalar_exprs: &[ScalarExprPlan], + eval_families: &[NamedEvalFamilyPlan], store: &ValueStore, instance: &SumcheckInstanceResultPlan, evals: &[StageNamedEval], @@ -1352,6 +1387,7 @@ pub fn evaluate_relation_output_for_instance( relation_output, field_exprs, scalar_exprs, + eval_families, store, instance.symbol, evals, @@ -1369,6 +1405,7 @@ pub fn evaluate_relation_output_batch( relation_outputs: &[RelationOutputPlan], field_exprs: &[FieldExprPlan], scalar_exprs: &[ScalarExprPlan], + eval_families: &[NamedEvalFamilyPlan], store: &ValueStore, evals: &[StageNamedEval], point: &[Fr], @@ -1406,6 +1443,7 @@ where relation_outputs, field_exprs, scalar_exprs, + eval_families, store, instance, evals, @@ -1418,20 +1456,19 @@ where Ok(expected) } -fn relation_output_x_point_source<'a>( +fn try_relation_output_x_point_source<'a>( source: &'static str, instance_symbol: &'static str, local_points: &'a [NamedPoint<'a, Fr>], local_point: &'a [Fr], store: &'a ValueStore, -) -> Result<&'a [Fr], RuntimePlanError> { +) -> Option<&'a [Fr]> { local_points .iter() .find(|point| point.symbol == source) .map(|point| point.point) .or_else(|| (source == instance_symbol).then_some(local_point)) .or_else(|| store.try_point(source)) - .ok_or(RuntimePlanError::MissingValue { symbol: source }) } #[derive(Clone, Copy)] @@ -1439,6 +1476,7 @@ struct RelationOutputContext<'a> { instance_symbol: &'static str, local_points: &'a [NamedPoint<'a, Fr>], local_point: &'a [Fr], + local_field_vectors: &'a [NamedFieldVector], } fn evaluate_structured_polynomial_point( @@ -1600,7 +1638,13 @@ fn evaluate_relation_output_scalar_expr( let [symbol] = expr.operands else { return evaluate_scalar_expr(expr, &[]).map(Some); }; - let Some(values) = store.try_field_vector(symbol) else { + let Some(values) = context + .local_field_vectors + .iter() + .find(|field_vector| field_vector.symbol == *symbol) + .map(|field_vector| field_vector.values.as_slice()) + .or_else(|| store.try_field_vector(symbol)) + else { return Ok(None); }; evaluate_scalar_expr(expr, values).map(Some) @@ -1617,8 +1661,7 @@ fn evaluate_relation_output_scalar_expr( y_point, store, context, - ) - .map(Some), + ), ScalarExprKind::PowerStridedWeightedSum { .. } => expr .operands .iter() @@ -1631,13 +1674,15 @@ fn evaluate_relation_output_scalar_expr( let [source] = expr.operands else { return evaluate_scalar_expr(expr, &[]).map(Some); }; - let point = relation_output_x_point_source( + let Some(point) = try_relation_output_x_point_source( source, context.instance_symbol, context.local_points, context.local_point, store, - )?; + ) else { + return Ok(None); + }; let value = point .get(index) .copied() @@ -1659,19 +1704,22 @@ fn evaluate_structured_polynomial_scalar( y_transform: StructuredPolynomialPointTransform, store: &ValueStore, context: RelationOutputContext<'_>, -) -> Result { +) -> Result, RuntimePlanError> { require_operand_count(symbol, 2, operands.len())?; let x_source = operands[0]; let y_source = operands[1]; - let x_raw_point = relation_output_x_point_source( + let Some(x_raw_point) = try_relation_output_x_point_source( x_source, context.instance_symbol, context.local_points, context.local_point, store, - )?; - let y_raw_point = - store.point_or(y_source, |symbol| RuntimePlanError::MissingValue { symbol })?; + ) else { + return Ok(None); + }; + let Some(y_raw_point) = store.try_point(y_source) else { + return Ok(None); + }; let x_plan = StructuredPolynomialPointPlan { source: x_source, segment: x_transform.segment, @@ -1688,7 +1736,7 @@ fn evaluate_structured_polynomial_scalar( evaluate_structured_polynomial_point(x_plan, x_raw_point, x_raw_point, y_raw_point)?; let y_point = evaluate_structured_polynomial_point(y_plan, y_raw_point, x_raw_point, y_raw_point)?; - evaluate_structured_polynomial(polynomial, &x_point, y_point) + evaluate_structured_polynomial(polynomial, &x_point, y_point).map(Some) } pub fn single_operand( @@ -2036,7 +2084,7 @@ mod tests { use super::{ evaluate_relation_output_for_instance, evaluate_scalar_expr, FieldExprKind, FieldExprPlan, Fr, NamedEvalFamilyPlan, RelationOutputPlan, RuntimePlanError, ScalarExprKind, - ScalarExprPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, + ScalarExprPlan, StageNamedEval, StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointSegment, StructuredPolynomialPointTransform, SumcheckInstanceResultPlan, SumcheckPointOrder, ValueStore, @@ -2045,6 +2093,7 @@ mod tests { #[derive(Clone, Copy, Debug, PartialEq, Eq)] enum TestRelation { Output, + Sibling, } #[test] @@ -2202,6 +2251,7 @@ mod tests { }, operands: &["instance", "point.y"], }], + &[], &store, &SumcheckInstanceResultPlan { symbol: "instance", @@ -2225,6 +2275,127 @@ mod tests { assert_eq!(value, Fr::from_u64(1)); } + #[test] + fn relation_output_skips_unavailable_sibling_instance_exprs() { + let x = [Fr::from_u64(1), Fr::from_u64(0)]; + let mut store = ValueStore::default(); + store.insert_point("point.y", x.to_vec()); + + let structured_eq = ScalarExprKind::StructuredPolynomial { + polynomial: StructuredPolynomialKind::Eq, + x_point: StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + y_point: StructuredPolynomialPointTransform { + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + }; + let value = evaluate_relation_output_for_instance( + &[ + RelationOutputPlan { + relation: TestRelation::Output, + local_scalars: &[], + expected_output: "eq.current", + }, + RelationOutputPlan { + relation: TestRelation::Sibling, + local_scalars: &[], + expected_output: "eq.sibling", + }, + ], + &[], + &[ + ScalarExprPlan { + symbol: "eq.sibling", + kind: structured_eq, + operands: &["sibling.instance", "point.y"], + }, + ScalarExprPlan { + symbol: "eq.current", + kind: structured_eq, + operands: &["instance", "point.y"], + }, + ], + &[], + &store, + &SumcheckInstanceResultPlan { + symbol: "instance", + source: "driver", + claim: "claim", + relation: TestRelation::Output, + index: 0, + point_arity: 2, + num_rounds: 2, + round_offset: 0, + point_order: SumcheckPointOrder::AsIs, + degree: 2, + }, + &[], + &[], + &[], + &x, + ) + .unwrap(); + + assert_eq!(value, Fr::from_u64(1)); + } + + #[test] + fn relation_output_evaluates_eval_family_vectors_from_proof_evals() { + let value = evaluate_relation_output_for_instance( + &[RelationOutputPlan { + relation: TestRelation::Output, + local_scalars: &[], + expected_output: "family.product", + }], + &[], + &[ScalarExprPlan { + symbol: "family.product", + kind: ScalarExprKind::FieldVectorProduct, + operands: &["family.ab"], + }], + &[NamedEvalFamilyPlan { + symbol: "family.ab", + evals: &["eval.a", "eval.b"], + }], + &ValueStore::default(), + &SumcheckInstanceResultPlan { + symbol: "instance", + source: "driver", + claim: "claim", + relation: TestRelation::Output, + index: 0, + point_arity: 0, + num_rounds: 0, + round_offset: 0, + point_order: SumcheckPointOrder::AsIs, + degree: 2, + }, + &[ + StageNamedEval { + name: "eval.a", + oracle: "A", + value: Fr::from_u64(2), + }, + StageNamedEval { + name: "eval.b", + oracle: "B", + value: Fr::from_u64(3), + }, + ], + &[], + &[], + &[], + ) + .unwrap(); + + assert_eq!(value, Fr::from_u64(6)); + } + #[test] fn relation_output_rejects_structured_polynomial_dimension_mismatch() { let x = [Fr::from_u64(1)]; @@ -2256,6 +2427,7 @@ mod tests { }, operands: &["instance", "point.y"], }], + &[], &store, &SumcheckInstanceResultPlan { symbol: "instance", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 66a14ddb4a..434980d2ee 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -2556,6 +2556,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + &[], &store.0, &proof.evals, &output.point, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 575acd3f9a..03d004663d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1784,6 +1784,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + &[], store, evals, point, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 9efa6dad5d..85ba90c895 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -1114,6 +1114,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); } else { "" }; + let indexed_eval_families_field = if self.role == Role::Verifier { + " indexed_eval_families: &[],\n" + } else { + "" + }; let scalar_exprs_field = if self.role == Role::Verifier { " scalar_exprs: STAGE4_SCALAR_EXPRS,\n" } else { @@ -1143,6 +1148,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage4Error); \x20 drivers: STAGE4_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE4_SUMCHECK_EVALS,\n\ + {indexed_eval_families_field}\ {relation_outputs_field}\ {point_exprs_field}\ \x20 opening_claims: STAGE4_OPENING_CLAIMS,\n\ @@ -2035,6 +2041,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + &[], store, evals, point, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 0bb1cf7156..5774499d27 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -128,6 +128,12 @@ pub fn emit_stage5_rust(module: &BoltModule<'_, Cpu>) -> Result impl Iterator { + self.indexed_eval_families + .iter() + .map(|family| (family.symbol.as_str(), family.evals.as_slice())) + } + fn from_module(module: &BoltModule<'_, Cpu>) -> Result { let mut params = None; let mut steps = Vec::new(); @@ -1215,6 +1221,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } else { "" }; + let indexed_eval_families_field = if self.role == Role::Verifier { + " indexed_eval_families: STAGE5_INDEXED_EVAL_FAMILIES,\n" + } else { + "" + }; let scalar_exprs_field = if self.role == Role::Verifier { " scalar_exprs: STAGE5_SCALAR_EXPRS,\n" } else { @@ -1244,6 +1255,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); \x20 drivers: STAGE5_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE5_SUMCHECK_EVALS,\n\ + {indexed_eval_families_field}\ {relation_outputs_field}\ {point_exprs_field}\ \x20 opening_claims: STAGE5_OPENING_CLAIMS,\n\ @@ -2114,6 +2126,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + program.indexed_eval_families, store, evals, point, @@ -2158,7 +2171,7 @@ fn observe_stage5_sumcheck_output( }, |symbol| VerifyStage5Error::MissingValue { symbol }, )?; - store.evaluate_named_eval_families(STAGE5_INDEXED_EVAL_FAMILIES)?; + store.evaluate_named_eval_families(program.indexed_eval_families)?; store.evaluate_available_points( program.point_exprs, |input, expected, actual| VerifyStage5Error::InvalidInputLength { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index ab682fc7f9..f2960dc1e0 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -140,6 +140,12 @@ pub fn emit_stage6_rust(module: &BoltModule<'_, Cpu>) -> Result impl Iterator { + self.indexed_eval_families + .iter() + .map(|family| (family.symbol.as_str(), family.evals.as_slice())) + } + fn from_module(module: &BoltModule<'_, Cpu>) -> Result { let mut params = None; let mut steps = Vec::new(); @@ -1309,6 +1315,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); } else { "" }; + let indexed_eval_families_field = if self.role == Role::Verifier { + " indexed_eval_families: STAGE6_INDEXED_EVAL_FAMILIES,\n" + } else { + "" + }; let scalar_exprs_field = if self.role == Role::Verifier { " scalar_exprs: STAGE6_SCALAR_EXPRS,\n" } else { @@ -1338,6 +1349,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); \x20 drivers: STAGE6_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE6_SUMCHECK_EVALS,\n\ + {indexed_eval_families_field}\ {relation_outputs_field}\ {point_exprs_field}\ \x20 opening_claims: STAGE6_OPENING_CLAIMS,\n\ @@ -2246,6 +2258,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + program.indexed_eval_families, store, evals, point, @@ -2291,7 +2304,7 @@ fn observe_stage6_sumcheck_output( }, |symbol| VerifyStage6Error::MissingValue { symbol }, )?; - store.evaluate_named_eval_families(STAGE6_INDEXED_EVAL_FAMILIES)?; + store.evaluate_named_eval_families(program.indexed_eval_families)?; store.evaluate_available_points( program.point_exprs, |input, expected, actual| VerifyStage6Error::InvalidInputLength { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index fa765a470e..2db0dca190 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -1342,6 +1342,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); } else { "" }; + let indexed_eval_families_field = if self.role == Role::Verifier { + " indexed_eval_families: &[],\n" + } else { + "" + }; let scalar_exprs_field = if self.role == Role::Verifier { " scalar_exprs: STAGE7_SCALAR_EXPRS,\n" } else { @@ -1371,6 +1376,7 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage7Error); \x20 drivers: STAGE7_SUMCHECK_DRIVERS,\n\ \x20 instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS,\n\ \x20 evals: STAGE7_SUMCHECK_EVALS,\n\ + {indexed_eval_families_field}\ {relation_outputs_field}\ {point_exprs_field}\ \x20 opening_claims: STAGE7_OPENING_CLAIMS,\n\ @@ -2261,6 +2267,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + &[], store, evals, point, diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 8f6c3e4052..14b89d8fac 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -611,6 +611,8 @@ macro_rules! define_stage_adapter_impl { $(, generated_points_with_zeros = $generated_point_with_zeros:ident, $generated_point_zero:ident)? $(, kernel_points = $kernel_point_slice:ident, $kernel_point_concat:ident)? $(, kernel_points_with_zeros = $kernel_point_slice_with_zeros:ident, $kernel_point_concat_with_zeros:ident, $kernel_point_zero:ident)? + $(, indexed_eval_families = $indexed_eval_families:ident)? + $(, empty_indexed_eval_families = $empty_indexed_eval_families:ident)? $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? $(, opening_equalities = $opening_equality:ident)? @@ -777,6 +779,17 @@ macro_rules! define_stage_adapter_impl { .collect(), ), $( + indexed_eval_families: super::leak_named_eval_family_rows( + program.$indexed_eval_families() + ), + )? + $( + indexed_eval_families: { + let _ = stringify!($empty_indexed_eval_families); + &[] + }, + )? + $( relation_outputs: super::leak_slice( program .relation_outputs @@ -958,6 +971,8 @@ macro_rules! define_stage_adapter { point_zero = $point_zero:ident $(, scalar_expr = $scalar_expr:ident)? $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? + $(, indexed_eval_families = $indexed_eval_families:ident)? + $(, empty_indexed_eval_families = $empty_indexed_eval_families:ident)? $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? ) => { @@ -987,6 +1002,8 @@ macro_rules! define_stage_adapter { $(, empty_scalar_exprs = $empty_scalar_exprs)? , generated_points_with_zeros = $point_expr, $point_zero + $(, indexed_eval_families = $indexed_eval_families)? + $(, empty_indexed_eval_families = $empty_indexed_eval_families)? $(, relation_outputs = $relation_output)? $(, empty_relation_outputs = $empty_relation_outputs)? , @@ -1019,6 +1036,8 @@ macro_rules! define_stage_adapter { $opening_batch:ident $(, scalar_expr = $scalar_expr:ident)? $(, empty_scalar_exprs = $empty_scalar_exprs:ident)? + $(, indexed_eval_families = $indexed_eval_families:ident)? + $(, empty_indexed_eval_families = $empty_indexed_eval_families:ident)? $(, relation_outputs = $relation_output:ident)? $(, empty_relation_outputs = $empty_relation_outputs:ident)? ) => { @@ -1048,6 +1067,8 @@ macro_rules! define_stage_adapter { $(, empty_scalar_exprs = $empty_scalar_exprs)? , generated_points = $point_expr + $(, indexed_eval_families = $indexed_eval_families)? + $(, empty_indexed_eval_families = $empty_indexed_eval_families)? $(, relation_outputs = $relation_output)? $(, empty_relation_outputs = $empty_relation_outputs)? , @@ -1812,6 +1833,21 @@ fn leak_str_slice(values: &[String]) -> &'static [&'static str] { Box::leak(leaked.into_boxed_slice()) } +fn leak_named_eval_family_rows<'a>( + rows: impl IntoIterator, +) -> &'static [bolt_verifier_runtime::NamedEvalFamilyPlan] { + leak_slice( + rows.into_iter() + .map( + |(symbol, evals)| bolt_verifier_runtime::NamedEvalFamilyPlan { + symbol: leak_str(symbol), + evals: leak_str_slice(evals), + }, + ) + .collect(), + ) +} + fn leak_usize_slice(values: &[usize]) -> &'static [usize] { Box::leak(values.to_vec().into_boxed_slice()) } diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs index 6159c03f91..80e727fde6 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage4.rs @@ -26,5 +26,6 @@ define_stage_adapter!( Stage4OpeningClaimEqualityPlan, Stage4OpeningBatchPlan, scalar_expr = Stage4ScalarExprPlan, + empty_indexed_eval_families = empty_indexed_eval_families, relation_outputs = Stage4RelationOutputPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs index 4a77eb7f75..1c93120afa 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs @@ -26,5 +26,6 @@ define_stage_adapter!( Stage5OpeningClaimEqualityPlan, Stage5OpeningBatchPlan, scalar_expr = Stage5ScalarExprPlan, + indexed_eval_families = indexed_eval_family_rows, relation_outputs = Stage5RelationOutputPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs index 9525d425f7..c53036add7 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs @@ -27,5 +27,6 @@ define_stage_adapter!( Stage6OpeningBatchPlan, point_zero = Stage6PointExprPlan, scalar_expr = Stage6ScalarExprPlan, + indexed_eval_families = indexed_eval_family_rows, relation_outputs = Stage6RelationOutputPlan ); diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs index 77d622cae9..3066e45cf4 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage7.rs @@ -27,5 +27,6 @@ define_stage_adapter!( Stage7OpeningBatchPlan, point_zero = Stage7PointExprPlan, scalar_expr = Stage7ScalarExprPlan, + empty_indexed_eval_families = empty_indexed_eval_families, relation_outputs = Stage7RelationOutputPlan ); diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index 5a59738bca..1915dea97d 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -541,6 +541,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + &[], &store.0, &proof.evals, &output.point, diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index d1656a437c..36ddb5d506 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -399,6 +399,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + &[], store, evals, point, diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 2fdb7a647e..378ab3f857 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -193,6 +193,7 @@ pub const STAGE4_PROGRAM: Stage4VerifierProgramPlan = Stage4CpuProgramPlan { drivers: STAGE4_SUMCHECK_DRIVERS, instance_results: STAGE4_SUMCHECK_INSTANCE_RESULTS, evals: STAGE4_SUMCHECK_EVALS, + indexed_eval_families: &[], relation_outputs: STAGE4_RELATION_OUTPUTS, point_exprs: STAGE4_POINT_EXPRS, opening_claims: STAGE4_OPENING_CLAIMS, @@ -377,6 +378,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + &[], store, evals, point, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 959712e76c..9b5645e224 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -426,6 +426,7 @@ pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { drivers: STAGE5_SUMCHECK_DRIVERS, instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS, evals: STAGE5_SUMCHECK_EVALS, + indexed_eval_families: STAGE5_INDEXED_EVAL_FAMILIES, relation_outputs: STAGE5_RELATION_OUTPUTS, point_exprs: STAGE5_POINT_EXPRS, opening_claims: STAGE5_OPENING_CLAIMS, @@ -610,6 +611,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + program.indexed_eval_families, store, evals, point, @@ -654,7 +656,7 @@ fn observe_stage5_sumcheck_output( }, |symbol| VerifyStage5Error::MissingValue { symbol }, )?; - store.evaluate_named_eval_families(STAGE5_INDEXED_EVAL_FAMILIES)?; + store.evaluate_named_eval_families(program.indexed_eval_families)?; store.evaluate_available_points( program.point_exprs, |input, expected, actual| VerifyStage5Error::InvalidInputLength { diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index f514b42ddb..e5f8f88ba1 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -680,6 +680,7 @@ pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { drivers: STAGE6_SUMCHECK_DRIVERS, instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS, evals: STAGE6_SUMCHECK_EVALS, + indexed_eval_families: STAGE6_INDEXED_EVAL_FAMILIES, relation_outputs: STAGE6_RELATION_OUTPUTS, point_exprs: STAGE6_POINT_EXPRS, opening_claims: STAGE6_OPENING_CLAIMS, @@ -880,6 +881,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + program.indexed_eval_families, store, evals, point, @@ -925,7 +927,7 @@ fn observe_stage6_sumcheck_output( }, |symbol| VerifyStage6Error::MissingValue { symbol }, )?; - store.evaluate_named_eval_families(STAGE6_INDEXED_EVAL_FAMILIES)?; + store.evaluate_named_eval_families(program.indexed_eval_families)?; store.evaluate_available_points( program.point_exprs, |input, expected, actual| VerifyStage6Error::InvalidInputLength { diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index ccdc1e17d1..44f009d2a9 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -290,6 +290,7 @@ pub const STAGE7_PROGRAM: Stage7VerifierProgramPlan = Stage7CpuProgramPlan { drivers: STAGE7_SUMCHECK_DRIVERS, instance_results: STAGE7_SUMCHECK_INSTANCE_RESULTS, evals: STAGE7_SUMCHECK_EVALS, + indexed_eval_families: &[], relation_outputs: STAGE7_RELATION_OUTPUTS, point_exprs: STAGE7_POINT_EXPRS, opening_claims: STAGE7_OPENING_CLAIMS, @@ -481,6 +482,7 @@ where program.relation_outputs, program.field_exprs, program.scalar_exprs, + &[], store, evals, point, From 52a482404709fd6712c7ca9e382332cf4aca858e Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 06:56:06 -0600 Subject: [PATCH 139/171] refactor(verifier): pass relation output to local inputs Thread the selected RelationOutputPlan into local-input construction so Stage 5/6 filter candidate local scalars by the program-declared local_scalars list. Keep the selection generic in bolt-verifier-runtime instead of adding protocol-math helpers to generated jolt_relations, preserving the Tier B verifier LOC ceiling. --- crates/bolt-verifier-runtime/src/lib.rs | 32 ++++++++++++++++--- .../src/protocols/jolt/emit/rust/stage2.rs | 2 +- .../src/protocols/jolt/emit/rust/stage3.rs | 2 +- .../src/protocols/jolt/emit/rust/stage4.rs | 2 +- .../src/protocols/jolt/emit/rust/stage5.rs | 10 ++++-- .../src/protocols/jolt/emit/rust/stage6.rs | 26 ++++++++------- .../src/protocols/jolt/emit/rust/stage7.rs | 2 +- crates/jolt-verifier/src/stages/stage2.rs | 2 +- crates/jolt-verifier/src/stages/stage3.rs | 2 +- crates/jolt-verifier/src/stages/stage4.rs | 2 +- crates/jolt-verifier/src/stages/stage5.rs | 10 ++++-- crates/jolt-verifier/src/stages/stage6.rs | 26 ++++++++------- crates/jolt-verifier/src/stages/stage7.rs | 2 +- 13 files changed, 80 insertions(+), 40 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 57577e2faa..3675cbed02 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -581,6 +581,22 @@ impl RelationOutputInputs<'_, F> { } } +pub fn select_named_scalars( + required_symbols: &[&'static str], + scalars: Vec>, +) -> Result>, RuntimePlanError> { + required_symbols + .iter() + .map(|&symbol| { + scalars + .iter() + .find(|scalar| scalar.symbol == symbol) + .cloned() + .ok_or(RuntimePlanError::MissingValue { symbol }) + }) + .collect() +} + #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct NamedEvalFamilyPlan { pub symbol: &'static str, @@ -1417,6 +1433,7 @@ where E: From, LocalInputs: for<'a> FnMut( &SumcheckInstanceResultPlan, + &RelationOutputPlan, &'a [Fr], ) -> Result, E>, { @@ -1431,6 +1448,13 @@ where batch: batch.symbol, claim: claim.symbol, })?; + let relation_output = relation_outputs + .iter() + .find(|relation_output| relation_output.relation == instance.relation) + .ok_or(RuntimePlanError::InvalidProof { + driver: instance.symbol, + reason: "missing relation output for relation", + })?; let local_point = point .get(instance.round_offset..instance.round_offset + instance.num_rounds) .ok_or(RuntimePlanError::InvalidInputLength { @@ -1438,14 +1462,14 @@ where expected: instance.round_offset + instance.num_rounds, actual: point.len(), })?; - let inputs = local_inputs(instance, local_point)?; - let value = evaluate_relation_output_for_instance( - relation_outputs, + let inputs = local_inputs(instance, relation_output, local_point)?; + let value = evaluate_relation_output( + relation_output, field_exprs, scalar_exprs, eval_families, store, - instance, + instance.symbol, evals, &inputs.scalars, &inputs.points, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 434980d2ee..122a7c92a4 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -2561,7 +2561,7 @@ where &proof.evals, &output.point, &batching_coeffs, - |instance, local_point| stage2_relation_output_inputs(&*store, ram, instance, local_point), + |instance, _, local_point| stage2_relation_output_inputs(&*store, ram, instance, local_point), )?; if output.value != expected { return Err(VerifyStage2Error::InvalidProof { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 03d004663d..c1279f8a65 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1789,7 +1789,7 @@ where evals, point, batching_coeffs, - |_, _| Ok::<_, VerifyStage3Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + |_, _, _| Ok::<_, VerifyStage3Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), ) }, |store, verified| observe_stage3_sumcheck_output(program, store, verified), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 85ba90c895..d0b0a3b0fb 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -2046,7 +2046,7 @@ where evals, point, batching_coeffs, - |_, _| Ok::<_, VerifyStage4Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + |_, _, _| Ok::<_, VerifyStage4Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), ) }, |store, verified| observe_stage4_sumcheck_output(program, store, verified), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 5774499d27..36c93a3821 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -2192,6 +2192,7 @@ fn observe_stage5_sumcheck_output( fn stage5_relation_output_inputs<'a>( instance: &Stage5SumcheckInstanceResultPlan, + relation_output: &Stage5RelationOutputPlan, local_point: &'a [Fr], ) -> Result, VerifyStage5Error> { if instance.relation != Stage5RelationKind::Stage5InstructionReadRaf { @@ -2199,9 +2200,12 @@ fn stage5_relation_output_inputs<'a>( } Ok(bolt_verifier_runtime::RelationOutputInputs { - scalars: evaluate_stage5_instruction_read_raf_point_scalars( - &STAGE5_INSTRUCTION_READ_RAF_PLAN, - local_point, + scalars: bolt_verifier_runtime::select_named_scalars( + relation_output.local_scalars, + evaluate_stage5_instruction_read_raf_point_scalars( + &STAGE5_INSTRUCTION_READ_RAF_PLAN, + local_point, + )?, )?, points: Vec::new(), }) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index f2960dc1e0..4d2f6630d6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -2263,8 +2263,8 @@ where evals, point, batching_coeffs, - |instance, local_point| { - stage6_relation_output_inputs(program, verifier_data, store, instance, local_point) + |instance, relation_output, local_point| { + stage6_relation_output_inputs(program, verifier_data, store, instance, relation_output, local_point) }, ) }, @@ -2328,6 +2328,7 @@ fn stage6_relation_output_inputs<'a>( verifier_data: Option<&Stage6VerifierData>, store: &bolt_verifier_runtime::ValueStore, instance: &Stage6SumcheckInstanceResultPlan, + relation_output: &Stage6RelationOutputPlan, local_point: &'a [Fr], ) -> Result, VerifyStage6Error> { if instance.relation != Stage6RelationKind::Stage6BytecodeReadRaf { @@ -2338,16 +2339,19 @@ fn stage6_relation_output_inputs<'a>( .and_then(|data| data.bytecode_read_raf.as_ref()) .ok_or(VerifyStage6Error::MissingValue { symbol: "stage6.bytecode_read_raf.data", - })?; + })?; Ok(bolt_verifier_runtime::RelationOutputInputs { - scalars: evaluate_stage67_bytecode_read_raf_output_scalars( - &STAGE6_BYTECODE_PLAN, - &data.entries, - data.entry_bytecode_index, - data.num_lookup_tables, - store, - local_point, - stage6_trace_rounds(program)?, + scalars: bolt_verifier_runtime::select_named_scalars( + relation_output.local_scalars, + evaluate_stage67_bytecode_read_raf_output_scalars( + &STAGE6_BYTECODE_PLAN, + &data.entries, + data.entry_bytecode_index, + data.num_lookup_tables, + store, + local_point, + stage6_trace_rounds(program)?, + )?, )?, points: Vec::new(), }) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 2db0dca190..ad2ae73fc4 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -2272,7 +2272,7 @@ where evals, point, batching_coeffs, - |_, _| Ok::<_, VerifyStage7Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + |_, _, _| Ok::<_, VerifyStage7Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), ) }, |store, verified| observe_stage7_sumcheck_output(program, store, verified), diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index 1915dea97d..935349014d 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -546,7 +546,7 @@ where &proof.evals, &output.point, &batching_coeffs, - |instance, local_point| stage2_relation_output_inputs(&*store, ram, instance, local_point), + |instance, _, local_point| stage2_relation_output_inputs(&*store, ram, instance, local_point), )?; if output.value != expected { return Err(VerifyStage2Error::InvalidProof { diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 36ddb5d506..0d894e9eb6 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -404,7 +404,7 @@ where evals, point, batching_coeffs, - |_, _| Ok::<_, VerifyStage3Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + |_, _, _| Ok::<_, VerifyStage3Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), ) }, |store, verified| observe_stage3_sumcheck_output(program, store, verified), diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 378ab3f857..9bfcbbaf82 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -383,7 +383,7 @@ where evals, point, batching_coeffs, - |_, _| Ok::<_, VerifyStage4Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + |_, _, _| Ok::<_, VerifyStage4Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), ) }, |store, verified| observe_stage4_sumcheck_output(program, store, verified), diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 9b5645e224..4349bcd2d4 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -677,6 +677,7 @@ fn observe_stage5_sumcheck_output( fn stage5_relation_output_inputs<'a>( instance: &Stage5SumcheckInstanceResultPlan, + relation_output: &Stage5RelationOutputPlan, local_point: &'a [Fr], ) -> Result, VerifyStage5Error> { if instance.relation != Stage5RelationKind::Stage5InstructionReadRaf { @@ -684,9 +685,12 @@ fn stage5_relation_output_inputs<'a>( } Ok(bolt_verifier_runtime::RelationOutputInputs { - scalars: evaluate_stage5_instruction_read_raf_point_scalars( - &STAGE5_INSTRUCTION_READ_RAF_PLAN, - local_point, + scalars: bolt_verifier_runtime::select_named_scalars( + relation_output.local_scalars, + evaluate_stage5_instruction_read_raf_point_scalars( + &STAGE5_INSTRUCTION_READ_RAF_PLAN, + local_point, + )?, )?, points: Vec::new(), }) diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index e5f8f88ba1..3f68fb9604 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -886,8 +886,8 @@ where evals, point, batching_coeffs, - |instance, local_point| { - stage6_relation_output_inputs(program, verifier_data, store, instance, local_point) + |instance, relation_output, local_point| { + stage6_relation_output_inputs(program, verifier_data, store, instance, relation_output, local_point) }, ) }, @@ -951,6 +951,7 @@ fn stage6_relation_output_inputs<'a>( verifier_data: Option<&Stage6VerifierData>, store: &bolt_verifier_runtime::ValueStore, instance: &Stage6SumcheckInstanceResultPlan, + relation_output: &Stage6RelationOutputPlan, local_point: &'a [Fr], ) -> Result, VerifyStage6Error> { if instance.relation != Stage6RelationKind::Stage6BytecodeReadRaf { @@ -961,16 +962,19 @@ fn stage6_relation_output_inputs<'a>( .and_then(|data| data.bytecode_read_raf.as_ref()) .ok_or(VerifyStage6Error::MissingValue { symbol: "stage6.bytecode_read_raf.data", - })?; + })?; Ok(bolt_verifier_runtime::RelationOutputInputs { - scalars: evaluate_stage67_bytecode_read_raf_output_scalars( - &STAGE6_BYTECODE_PLAN, - &data.entries, - data.entry_bytecode_index, - data.num_lookup_tables, - store, - local_point, - stage6_trace_rounds(program)?, + scalars: bolt_verifier_runtime::select_named_scalars( + relation_output.local_scalars, + evaluate_stage67_bytecode_read_raf_output_scalars( + &STAGE6_BYTECODE_PLAN, + &data.entries, + data.entry_bytecode_index, + data.num_lookup_tables, + store, + local_point, + stage6_trace_rounds(program)?, + )?, )?, points: Vec::new(), }) diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index 44f009d2a9..d12feb9bb5 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -487,7 +487,7 @@ where evals, point, batching_coeffs, - |_, _| Ok::<_, VerifyStage7Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), + |_, _, _| Ok::<_, VerifyStage7Error>(bolt_verifier_runtime::RelationOutputInputs::empty()), ) }, |store, verified| observe_stage7_sumcheck_output(program, store, verified), From 1ed06be5b495bb820955e17f1cecc8c7f15e9048 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 07:26:43 -0600 Subject: [PATCH 140/171] refactor(verifier): own local input plans --- .../src/protocols/jolt/emit/rust/stage5.rs | 90 +++++++++++++------ .../src/protocols/jolt/emit/rust/stage6.rs | 85 ++++++++++++------ .../jolt/stage6_bytecode_read_raf_plan.rs | 4 +- .../src/plan_adapters/generated_stage5.rs | 13 ++- .../src/plan_adapters/generated_stage6.rs | 13 ++- crates/jolt-verifier/src/stages/stage5.rs | 69 ++++++++------ crates/jolt-verifier/src/stages/stage6.rs | 66 ++++++++------ 7 files changed, 227 insertions(+), 113 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 36c93a3821..c8f402bdab 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -1184,7 +1184,20 @@ pub use bolt_verifier_runtime::{ source.push_str( r#" pub type DefaultStage5Transcript = Blake2bTranscript; -pub type Stage5VerifierProgramPlan = Stage5CpuProgramPlan; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage5VerifierProgramPlan { + pub base: Stage5CpuProgramPlan, + pub instruction_read_raf_plan: Stage5InstructionReadRafPlan, +} + +impl core::ops::Deref for Stage5VerifierProgramPlan { + type Target = Stage5CpuProgramPlan; + + fn deref(&self) -> &Self::Target { + &self.base + } +} #[derive(Debug)] pub enum VerifyStage5Error { @@ -1216,51 +1229,67 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); source.push_str(&self.emit_indexed_eval_family_constants()?); source.push_str(&self.emit_verifier_relation_output_constants()?); } + let program_field_indent = if self.role == Role::Verifier { + " " + } else { + " " + }; let relation_outputs_field = if self.role == Role::Verifier { - " relation_outputs: STAGE5_RELATION_OUTPUTS,\n" + format!("{program_field_indent}relation_outputs: STAGE5_RELATION_OUTPUTS,\n") } else { - "" + String::new() }; let indexed_eval_families_field = if self.role == Role::Verifier { - " indexed_eval_families: STAGE5_INDEXED_EVAL_FAMILIES,\n" + format!("{program_field_indent}indexed_eval_families: STAGE5_INDEXED_EVAL_FAMILIES,\n") } else { - "" + String::new() }; let scalar_exprs_field = if self.role == Role::Verifier { - " scalar_exprs: STAGE5_SCALAR_EXPRS,\n" + format!("{program_field_indent}scalar_exprs: STAGE5_SCALAR_EXPRS,\n") } else { - "" + String::new() }; let point_exprs_field = if self.role == Role::Verifier { - " point_exprs: STAGE5_POINT_EXPRS,\n" + format!("{program_field_indent}point_exprs: STAGE5_POINT_EXPRS,\n") } else { - " point_slices: STAGE5_POINT_SLICES,\n point_concats: STAGE5_POINT_CONCATS,\n" + format!("{program_field_indent}point_slices: STAGE5_POINT_SLICES,\n{program_field_indent}point_concats: STAGE5_POINT_CONCATS,\n") + }; + let program_constructor = if self.role == Role::Verifier { + "Stage5VerifierProgramPlan {\n base: Stage5CpuProgramPlan {" + } else { + "Stage5CpuProgramPlan {" + }; + let verifier_program_fields = if self.role == Role::Verifier { + " },\n instruction_read_raf_plan: STAGE5_INSTRUCTION_READ_RAF_PLAN,\n" + } else { + "" }; push_format( &mut source, format_args!( - "pub const STAGE5_PROGRAM: {} = Stage5CpuProgramPlan {{\n\ - \x20 role: {},\n\ - \x20 params: STAGE5_PARAMS,\n\ - \x20 steps: STAGE5_PROGRAM_STEPS,\n\ - \x20 transcript_squeezes: STAGE5_TRANSCRIPT_SQUEEZES,\n\ - \x20 transcript_absorb_bytes: STAGE5_TRANSCRIPT_ABSORB_BYTES,\n\ - \x20 opening_inputs: STAGE5_OPENING_INPUTS,\n\ - \x20 field_constants: STAGE5_FIELD_CONSTANTS,\n\ - \x20 field_exprs: STAGE5_FIELD_EXPRS,\n\ + "pub const STAGE5_PROGRAM: {} = {program_constructor}\n\ + {program_field_indent}role: {},\n\ + {program_field_indent}params: STAGE5_PARAMS,\n\ + {program_field_indent}steps: STAGE5_PROGRAM_STEPS,\n\ + {program_field_indent}transcript_squeezes: STAGE5_TRANSCRIPT_SQUEEZES,\n\ + {program_field_indent}transcript_absorb_bytes: STAGE5_TRANSCRIPT_ABSORB_BYTES,\n\ + {program_field_indent}opening_inputs: STAGE5_OPENING_INPUTS,\n\ + {program_field_indent}field_constants: STAGE5_FIELD_CONSTANTS,\n\ + {program_field_indent}field_exprs: STAGE5_FIELD_EXPRS,\n\ {scalar_exprs_field}\ - \x20 kernels: STAGE5_KERNELS,\n\ - \x20 claims: STAGE5_SUMCHECK_CLAIMS,\n\ - \x20 batches: STAGE5_SUMCHECK_BATCHES,\n\ - \x20 drivers: STAGE5_SUMCHECK_DRIVERS,\n\ - \x20 instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS,\n\ - \x20 evals: STAGE5_SUMCHECK_EVALS,\n\ + {program_field_indent}kernels: STAGE5_KERNELS,\n\ + {program_field_indent}claims: STAGE5_SUMCHECK_CLAIMS,\n\ + {program_field_indent}batches: STAGE5_SUMCHECK_BATCHES,\n\ + {program_field_indent}drivers: STAGE5_SUMCHECK_DRIVERS,\n\ + {program_field_indent}instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS,\n\ + {program_field_indent}evals: STAGE5_SUMCHECK_EVALS,\n\ {indexed_eval_families_field}\ {relation_outputs_field}\ {point_exprs_field}\ - \x20 opening_claims: STAGE5_OPENING_CLAIMS,\n\ - \x20 opening_equalities: STAGE5_OPENING_EQUALITIES,\n\ - \x20 opening_batches: STAGE5_OPENING_BATCHES,\n\ + {program_field_indent}opening_claims: STAGE5_OPENING_CLAIMS,\n\ + {program_field_indent}opening_equalities: STAGE5_OPENING_EQUALITIES,\n\ + {program_field_indent}opening_batches: STAGE5_OPENING_BATCHES,\n\ + {verifier_program_fields}\ }};\n", self.program_plan_type(), rust_str(self.role_label()) @@ -2131,7 +2160,9 @@ where evals, point, batching_coeffs, - stage5_relation_output_inputs, + |instance, relation_output, local_point| { + stage5_relation_output_inputs(program, instance, relation_output, local_point) + }, ) }, |store, verified| observe_stage5_sumcheck_output(program, store, verified), @@ -2191,6 +2222,7 @@ fn observe_stage5_sumcheck_output( } fn stage5_relation_output_inputs<'a>( + program: &'static Stage5VerifierProgramPlan, instance: &Stage5SumcheckInstanceResultPlan, relation_output: &Stage5RelationOutputPlan, local_point: &'a [Fr], @@ -2203,7 +2235,7 @@ fn stage5_relation_output_inputs<'a>( scalars: bolt_verifier_runtime::select_named_scalars( relation_output.local_scalars, evaluate_stage5_instruction_read_raf_point_scalars( - &STAGE5_INSTRUCTION_READ_RAF_PLAN, + &program.instruction_read_raf_plan, local_point, )?, )?, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 4d2f6630d6..067f007b72 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -1216,7 +1216,20 @@ pub use bolt_verifier_runtime::{ source.push_str( r#" pub type DefaultStage6Transcript = Blake2bTranscript; -pub type Stage6VerifierProgramPlan = Stage6CpuProgramPlan; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage6VerifierProgramPlan { + pub base: Stage6CpuProgramPlan, + pub bytecode_plan: Stage67BytecodeReadRafPlan, +} + +impl core::ops::Deref for Stage6VerifierProgramPlan { + type Target = Stage6CpuProgramPlan; + + fn deref(&self) -> &Self::Target { + &self.base + } +} #[derive(Clone, Debug)] pub struct Stage6BytecodeEntry { @@ -1310,51 +1323,67 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); )); source.push_str(&self.emit_verifier_relation_output_constants()?); } + let program_field_indent = if self.role == Role::Verifier { + " " + } else { + " " + }; let relation_outputs_field = if self.role == Role::Verifier { - " relation_outputs: STAGE6_RELATION_OUTPUTS,\n" + format!("{program_field_indent}relation_outputs: STAGE6_RELATION_OUTPUTS,\n") } else { - "" + String::new() }; let indexed_eval_families_field = if self.role == Role::Verifier { - " indexed_eval_families: STAGE6_INDEXED_EVAL_FAMILIES,\n" + format!("{program_field_indent}indexed_eval_families: STAGE6_INDEXED_EVAL_FAMILIES,\n") } else { - "" + String::new() }; let scalar_exprs_field = if self.role == Role::Verifier { - " scalar_exprs: STAGE6_SCALAR_EXPRS,\n" + format!("{program_field_indent}scalar_exprs: STAGE6_SCALAR_EXPRS,\n") } else { - "" + String::new() }; let point_exprs_field = if self.role == Role::Verifier { - " point_exprs: STAGE6_POINT_EXPRS,\n" + format!("{program_field_indent}point_exprs: STAGE6_POINT_EXPRS,\n") + } else { + format!("{program_field_indent}point_zeros: STAGE6_POINT_ZEROS,\n{program_field_indent}point_slices: STAGE6_POINT_SLICES,\n{program_field_indent}point_concats: STAGE6_POINT_CONCATS,\n") + }; + let program_constructor = if self.role == Role::Verifier { + "Stage6VerifierProgramPlan {\n base: Stage6CpuProgramPlan {" + } else { + "Stage6CpuProgramPlan {" + }; + let verifier_program_fields = if self.role == Role::Verifier { + " },\n bytecode_plan: STAGE6_BYTECODE_PLAN,\n" } else { - " point_zeros: STAGE6_POINT_ZEROS,\n point_slices: STAGE6_POINT_SLICES,\n point_concats: STAGE6_POINT_CONCATS,\n" + "" }; push_format( &mut source, format_args!( - "pub const STAGE6_PROGRAM: {} = Stage6CpuProgramPlan {{\n\ - \x20 role: {},\n\ - \x20 params: STAGE6_PARAMS,\n\ - \x20 steps: STAGE6_PROGRAM_STEPS,\n\ - \x20 transcript_squeezes: STAGE6_TRANSCRIPT_SQUEEZES,\n\ - \x20 transcript_absorb_bytes: STAGE6_TRANSCRIPT_ABSORB_BYTES,\n\ - \x20 opening_inputs: STAGE6_OPENING_INPUTS,\n\ - \x20 field_constants: STAGE6_FIELD_CONSTANTS,\n\ - \x20 field_exprs: STAGE6_FIELD_EXPRS,\n\ + "pub const STAGE6_PROGRAM: {} = {program_constructor}\n\ + {program_field_indent}role: {},\n\ + {program_field_indent}params: STAGE6_PARAMS,\n\ + {program_field_indent}steps: STAGE6_PROGRAM_STEPS,\n\ + {program_field_indent}transcript_squeezes: STAGE6_TRANSCRIPT_SQUEEZES,\n\ + {program_field_indent}transcript_absorb_bytes: STAGE6_TRANSCRIPT_ABSORB_BYTES,\n\ + {program_field_indent}opening_inputs: STAGE6_OPENING_INPUTS,\n\ + {program_field_indent}field_constants: STAGE6_FIELD_CONSTANTS,\n\ + {program_field_indent}field_exprs: STAGE6_FIELD_EXPRS,\n\ {scalar_exprs_field}\ - \x20 kernels: STAGE6_KERNELS,\n\ - \x20 claims: STAGE6_SUMCHECK_CLAIMS,\n\ - \x20 batches: STAGE6_SUMCHECK_BATCHES,\n\ - \x20 drivers: STAGE6_SUMCHECK_DRIVERS,\n\ - \x20 instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS,\n\ - \x20 evals: STAGE6_SUMCHECK_EVALS,\n\ + {program_field_indent}kernels: STAGE6_KERNELS,\n\ + {program_field_indent}claims: STAGE6_SUMCHECK_CLAIMS,\n\ + {program_field_indent}batches: STAGE6_SUMCHECK_BATCHES,\n\ + {program_field_indent}drivers: STAGE6_SUMCHECK_DRIVERS,\n\ + {program_field_indent}instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS,\n\ + {program_field_indent}evals: STAGE6_SUMCHECK_EVALS,\n\ {indexed_eval_families_field}\ {relation_outputs_field}\ {point_exprs_field}\ - \x20 opening_claims: STAGE6_OPENING_CLAIMS,\n\ - \x20 opening_equalities: STAGE6_OPENING_EQUALITIES,\n\ - \x20 opening_batches: STAGE6_OPENING_BATCHES,\n\ + {program_field_indent}opening_claims: STAGE6_OPENING_CLAIMS,\n\ + {program_field_indent}opening_equalities: STAGE6_OPENING_EQUALITIES,\n\ + {program_field_indent}opening_batches: STAGE6_OPENING_BATCHES,\n\ + {verifier_program_fields}\ }};\n", self.program_plan_type(), rust_str(self.role_label()) @@ -2344,7 +2373,7 @@ fn stage6_relation_output_inputs<'a>( scalars: bolt_verifier_runtime::select_named_scalars( relation_output.local_scalars, evaluate_stage67_bytecode_read_raf_output_scalars( - &STAGE6_BYTECODE_PLAN, + &program.bytecode_plan, &data.entries, data.entry_bytecode_index, data.num_lookup_tables, diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 8cc8d0dcea..99e984ce63 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -466,7 +466,7 @@ fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan, bytecode_ra_evals_ref push_format( &mut source, format_args!( - "const {}: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan {{\n", + "pub const {}: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan {{\n", plan.const_name ), ); @@ -789,7 +789,7 @@ mod tests { assert!(source .contains("output_contribution: \"stage6.bytecode_read_raf.output.contribution\"")); assert!(source.contains("bytecode_ra_evals: &STAGE6_INDEXED_EVAL_FAMILIES[0]")); - assert!(source.contains("const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan")); + assert!(source.contains("pub const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan")); } #[test] diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs index 1c93120afa..c04eb8ac50 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage5.rs @@ -3,10 +3,10 @@ use jolt_verifier::stages::stage5 as generated_stage5; define_stage_adapter!( generated, - leak_generated_stage5_verifier_program, + leak_generated_stage5_base_verifier_program, CompilerStage5CpuProgram, generated_stage5, - Stage5VerifierProgramPlan, + Stage5CpuProgramPlan, Stage5Params, Stage5ProgramStepPlan, Stage5TranscriptSqueezePlan, @@ -29,3 +29,12 @@ define_stage_adapter!( indexed_eval_families = indexed_eval_family_rows, relation_outputs = Stage5RelationOutputPlan ); + +pub fn leak_generated_stage5_verifier_program( + program: &CompilerStage5CpuProgram, +) -> &'static generated_stage5::Stage5VerifierProgramPlan { + Box::leak(Box::new(generated_stage5::Stage5VerifierProgramPlan { + base: *leak_generated_stage5_base_verifier_program(program), + instruction_read_raf_plan: generated_stage5::STAGE5_INSTRUCTION_READ_RAF_PLAN, + })) +} diff --git a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs index c53036add7..46a57c84b5 100644 --- a/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs +++ b/crates/jolt-equivalence/src/plan_adapters/generated_stage6.rs @@ -3,10 +3,10 @@ use jolt_verifier::stages::stage6 as generated_stage6; define_stage_adapter!( generated, - leak_generated_stage6_verifier_program, + leak_generated_stage6_base_verifier_program, CompilerStage6CpuProgram, generated_stage6, - Stage6VerifierProgramPlan, + Stage6CpuProgramPlan, Stage6Params, Stage6ProgramStepPlan, Stage6TranscriptSqueezePlan, @@ -30,3 +30,12 @@ define_stage_adapter!( indexed_eval_families = indexed_eval_family_rows, relation_outputs = Stage6RelationOutputPlan ); + +pub fn leak_generated_stage6_verifier_program( + program: &CompilerStage6CpuProgram, +) -> &'static generated_stage6::Stage6VerifierProgramPlan { + Box::leak(Box::new(generated_stage6::Stage6VerifierProgramPlan { + base: *leak_generated_stage6_base_verifier_program(program), + bytecode_plan: generated_stage6::STAGE6_BYTECODE_PLAN, + })) +} diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 4349bcd2d4..35c32b79ee 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -40,7 +40,20 @@ pub use bolt_verifier_runtime::{ }; pub type DefaultStage5Transcript = Blake2bTranscript; -pub type Stage5VerifierProgramPlan = Stage5CpuProgramPlan; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage5VerifierProgramPlan { + pub base: Stage5CpuProgramPlan, + pub instruction_read_raf_plan: Stage5InstructionReadRafPlan, +} + +impl core::ops::Deref for Stage5VerifierProgramPlan { + type Target = Stage5CpuProgramPlan; + + fn deref(&self) -> &Self::Target { + &self.base + } +} #[derive(Debug)] pub enum VerifyStage5Error { @@ -410,28 +423,31 @@ pub const STAGE5_RELATION_OUTPUTS: &[Stage5RelationOutputPlan] = &[ Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5InstructionReadRaf, local_scalars: STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS, expected_output: "stage5.instruction_read_raf.output.claim_expr" }, ]; -pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5CpuProgramPlan { - role: "verifier", - params: STAGE5_PARAMS, - steps: STAGE5_PROGRAM_STEPS, - transcript_squeezes: STAGE5_TRANSCRIPT_SQUEEZES, - transcript_absorb_bytes: STAGE5_TRANSCRIPT_ABSORB_BYTES, - opening_inputs: STAGE5_OPENING_INPUTS, - field_constants: STAGE5_FIELD_CONSTANTS, - field_exprs: STAGE5_FIELD_EXPRS, - scalar_exprs: STAGE5_SCALAR_EXPRS, - kernels: STAGE5_KERNELS, - claims: STAGE5_SUMCHECK_CLAIMS, - batches: STAGE5_SUMCHECK_BATCHES, - drivers: STAGE5_SUMCHECK_DRIVERS, - instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS, - evals: STAGE5_SUMCHECK_EVALS, - indexed_eval_families: STAGE5_INDEXED_EVAL_FAMILIES, - relation_outputs: STAGE5_RELATION_OUTPUTS, - point_exprs: STAGE5_POINT_EXPRS, - opening_claims: STAGE5_OPENING_CLAIMS, - opening_equalities: STAGE5_OPENING_EQUALITIES, - opening_batches: STAGE5_OPENING_BATCHES, +pub const STAGE5_PROGRAM: Stage5VerifierProgramPlan = Stage5VerifierProgramPlan { + base: Stage5CpuProgramPlan { + role: "verifier", + params: STAGE5_PARAMS, + steps: STAGE5_PROGRAM_STEPS, + transcript_squeezes: STAGE5_TRANSCRIPT_SQUEEZES, + transcript_absorb_bytes: STAGE5_TRANSCRIPT_ABSORB_BYTES, + opening_inputs: STAGE5_OPENING_INPUTS, + field_constants: STAGE5_FIELD_CONSTANTS, + field_exprs: STAGE5_FIELD_EXPRS, + scalar_exprs: STAGE5_SCALAR_EXPRS, + kernels: STAGE5_KERNELS, + claims: STAGE5_SUMCHECK_CLAIMS, + batches: STAGE5_SUMCHECK_BATCHES, + drivers: STAGE5_SUMCHECK_DRIVERS, + instance_results: STAGE5_SUMCHECK_INSTANCE_RESULTS, + evals: STAGE5_SUMCHECK_EVALS, + indexed_eval_families: STAGE5_INDEXED_EVAL_FAMILIES, + relation_outputs: STAGE5_RELATION_OUTPUTS, + point_exprs: STAGE5_POINT_EXPRS, + opening_claims: STAGE5_OPENING_CLAIMS, + opening_equalities: STAGE5_OPENING_EQUALITIES, + opening_batches: STAGE5_OPENING_BATCHES, + }, + instruction_read_raf_plan: STAGE5_INSTRUCTION_READ_RAF_PLAN, }; pub fn verify_stage5( @@ -616,7 +632,9 @@ where evals, point, batching_coeffs, - stage5_relation_output_inputs, + |instance, relation_output, local_point| { + stage5_relation_output_inputs(program, instance, relation_output, local_point) + }, ) }, |store, verified| observe_stage5_sumcheck_output(program, store, verified), @@ -676,6 +694,7 @@ fn observe_stage5_sumcheck_output( } fn stage5_relation_output_inputs<'a>( + program: &'static Stage5VerifierProgramPlan, instance: &Stage5SumcheckInstanceResultPlan, relation_output: &Stage5RelationOutputPlan, local_point: &'a [Fr], @@ -688,7 +707,7 @@ fn stage5_relation_output_inputs<'a>( scalars: bolt_verifier_runtime::select_named_scalars( relation_output.local_scalars, evaluate_stage5_instruction_read_raf_point_scalars( - &STAGE5_INSTRUCTION_READ_RAF_PLAN, + &program.instruction_read_raf_plan, local_point, )?, )?, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 3f68fb9604..374252f352 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -40,7 +40,20 @@ pub use bolt_verifier_runtime::{ }; pub type DefaultStage6Transcript = Blake2bTranscript; -pub type Stage6VerifierProgramPlan = Stage6CpuProgramPlan; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct Stage6VerifierProgramPlan { + pub base: Stage6CpuProgramPlan, + pub bytecode_plan: Stage67BytecodeReadRafPlan, +} + +impl core::ops::Deref for Stage6VerifierProgramPlan { + type Target = Stage6CpuProgramPlan; + + fn deref(&self) -> &Self::Target { + &self.base + } +} #[derive(Clone, Debug)] pub struct Stage6BytecodeEntry { @@ -638,7 +651,7 @@ const STAGE6_BYTECODE_OUTPUT_TERMS: &[Stage67BytecodeOutputTermPlan] = &[ Stage67BytecodeOutputTermPlan::Entry { symbol: "stage6.bytecode_read_raf.output.term.Entry", gamma_power: 7 }, ]; -const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { +pub const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan = Stage67BytecodeReadRafPlan { point: "stage6.bytecode_read_raf.point", gamma: "stage6.bytecode_read_raf.gamma", bytecode_ra_evals: &STAGE6_INDEXED_EVAL_FAMILIES[0], @@ -664,28 +677,31 @@ pub const STAGE6_RELATION_OUTPUTS: &[Stage6RelationOutputPlan] = &[ Stage6RelationOutputPlan { relation: Stage6RelationKind::Stage6BytecodeReadRaf, local_scalars: STAGE6_RELATION_OUTPUT_5_LOCAL_SCALARS, expected_output: "stage6.bytecode_read_raf.output.claim_expr" }, ]; -pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6CpuProgramPlan { - role: "verifier", - params: STAGE6_PARAMS, - steps: STAGE6_PROGRAM_STEPS, - transcript_squeezes: STAGE6_TRANSCRIPT_SQUEEZES, - transcript_absorb_bytes: STAGE6_TRANSCRIPT_ABSORB_BYTES, - opening_inputs: STAGE6_OPENING_INPUTS, - field_constants: STAGE6_FIELD_CONSTANTS, - field_exprs: STAGE6_FIELD_EXPRS, - scalar_exprs: STAGE6_SCALAR_EXPRS, - kernels: STAGE6_KERNELS, - claims: STAGE6_SUMCHECK_CLAIMS, - batches: STAGE6_SUMCHECK_BATCHES, - drivers: STAGE6_SUMCHECK_DRIVERS, - instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS, - evals: STAGE6_SUMCHECK_EVALS, - indexed_eval_families: STAGE6_INDEXED_EVAL_FAMILIES, - relation_outputs: STAGE6_RELATION_OUTPUTS, - point_exprs: STAGE6_POINT_EXPRS, - opening_claims: STAGE6_OPENING_CLAIMS, - opening_equalities: STAGE6_OPENING_EQUALITIES, - opening_batches: STAGE6_OPENING_BATCHES, +pub const STAGE6_PROGRAM: Stage6VerifierProgramPlan = Stage6VerifierProgramPlan { + base: Stage6CpuProgramPlan { + role: "verifier", + params: STAGE6_PARAMS, + steps: STAGE6_PROGRAM_STEPS, + transcript_squeezes: STAGE6_TRANSCRIPT_SQUEEZES, + transcript_absorb_bytes: STAGE6_TRANSCRIPT_ABSORB_BYTES, + opening_inputs: STAGE6_OPENING_INPUTS, + field_constants: STAGE6_FIELD_CONSTANTS, + field_exprs: STAGE6_FIELD_EXPRS, + scalar_exprs: STAGE6_SCALAR_EXPRS, + kernels: STAGE6_KERNELS, + claims: STAGE6_SUMCHECK_CLAIMS, + batches: STAGE6_SUMCHECK_BATCHES, + drivers: STAGE6_SUMCHECK_DRIVERS, + instance_results: STAGE6_SUMCHECK_INSTANCE_RESULTS, + evals: STAGE6_SUMCHECK_EVALS, + indexed_eval_families: STAGE6_INDEXED_EVAL_FAMILIES, + relation_outputs: STAGE6_RELATION_OUTPUTS, + point_exprs: STAGE6_POINT_EXPRS, + opening_claims: STAGE6_OPENING_CLAIMS, + opening_equalities: STAGE6_OPENING_EQUALITIES, + opening_batches: STAGE6_OPENING_BATCHES, + }, + bytecode_plan: STAGE6_BYTECODE_PLAN, }; pub fn verify_stage6( @@ -967,7 +983,7 @@ fn stage6_relation_output_inputs<'a>( scalars: bolt_verifier_runtime::select_named_scalars( relation_output.local_scalars, evaluate_stage67_bytecode_read_raf_output_scalars( - &STAGE6_BYTECODE_PLAN, + &program.bytecode_plan, &data.entries, data.entry_bytecode_index, data.num_lookup_tables, From 320c168aa155eb3d932ef73e7bbb80a5f16e44cb Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 07:42:47 -0600 Subject: [PATCH 141/171] refactor(verifier): route local input plans --- .../src/protocols/jolt/emit/rust/stage5.rs | 15 ++-- .../src/protocols/jolt/emit/rust/stage6.rs | 59 ++++++++------- .../jolt/stage6_bytecode_read_raf_plan.rs | 74 +++++++++++++------ .../protocols/jolt/verifier_eval_families.rs | 15 +--- .../bolt/src/protocols/jolt/verifier_plan.rs | 39 ++++++++++ 5 files changed, 132 insertions(+), 70 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index c8f402bdab..588ae841a6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -385,7 +385,11 @@ impl Stage5CpuProgram { } fn plan_verifier(&self) -> Result { - verifier_plan::stage_plan_from_cpu_sources(self) + let mut plan = verifier_plan::stage_plan_from_cpu_sources(self)?; + plan.relation_local_inputs.set_stage5_instruction_read_raf( + Stage5InstructionReadRafEmitPlan::from_eval_families(&plan.indexed_eval_families)?, + ); + Ok(plan) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { @@ -1771,10 +1775,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage5Error); } fn emit_named_eval_family_constants(&self) -> Result { - let plan = Stage5InstructionReadRafEmitPlan::from_eval_families( - &self.verifier_plan()?.indexed_eval_families, - )?; - Ok(plan.emit_runtime_constants()) + Ok(self + .verifier_plan()? + .relation_local_inputs + .stage5_instruction_read_raf()? + .emit_runtime_constants()) } fn emit_verifier_relation_output_constants(&self) -> Result { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 067f007b72..051b5a5941 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -14,10 +14,7 @@ use crate::protocols::jolt::cpu_attrs::{ operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr, }; use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; -use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ - emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, - stage6_bytecode_read_raf_relation_output_plan, STAGE6_BYTECODE_RA_EVAL_FAMILY, -}; +use crate::protocols::jolt::stage6_bytecode_read_raf_plan::Stage6BytecodeReadRafEmitPlan; use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; @@ -352,12 +349,9 @@ impl Stage6CpuProgram { Vec::new() }; if role == Role::Verifier { - let bytecode_ra_evals = IndexedEvalFamilyPlan::find( - &indexed_eval_families, - STAGE6_BYTECODE_RA_EVAL_FAMILY, - )?; let bytecode_output_plan = - stage6_bytecode_read_raf_relation_output_plan(bytecode_ra_evals); + Stage6BytecodeReadRafEmitPlan::from_eval_families(&indexed_eval_families)? + .relation_output_plan(); for expr in bytecode_output_plan.field_exprs { if ScalarExprKind::from_cpu_attr(&expr.formula).is_ok() { scalar_exprs.push(stage6_scalar_expr(expr)); @@ -411,7 +405,11 @@ impl Stage6CpuProgram { } fn plan_verifier(&self) -> Result { - verifier_plan::stage_plan_from_cpu_sources(self) + let mut plan = verifier_plan::stage_plan_from_cpu_sources(self)?; + plan.relation_local_inputs.set_stage6_bytecode_read_raf( + Stage6BytecodeReadRafEmitPlan::from_eval_families(&plan.indexed_eval_families)?, + ); + Ok(plan) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { @@ -1313,14 +1311,14 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage6Error); source.push_str(&self.emit_sumcheck_driver_constants()?); source.push_str(&self.emit_tail_constants()?); if self.role == Role::Verifier { - let (bytecode_ra_evals_ref, _) = stage6_bytecode_read_raf_eval_family_ref( - &self.verifier_plan()?.indexed_eval_families, - "STAGE6_INDEXED_EVAL_FAMILIES", - )?; + let plan = self.verifier_plan()?; source.push_str(&self.emit_indexed_eval_family_constants()?); - source.push_str(&emit_stage6_bytecode_read_raf_plan_constants( - &bytecode_ra_evals_ref, - )); + source.push_str( + &plan + .relation_local_inputs + .stage6_bytecode_read_raf()? + .emit_runtime_constants(), + ); source.push_str(&self.emit_verifier_relation_output_constants()?); } let program_field_indent = if self.role == Role::Verifier { @@ -2492,12 +2490,12 @@ fn stage6_kernel_abi(relation: &str) -> Option<&'static str> { #[cfg(test)] mod tests { use crate::emit::rust::EmitError; + use crate::protocols::jolt::stage6_bytecode_read_raf_plan::{ + Stage6BytecodeReadRafEmitPlan, STAGE6_BYTECODE_RA_EVAL_FAMILY, + }; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; - use super::{ - stage6_bytecode_read_raf_eval_family_ref, stage6_kernel_abi, - STAGE6_BYTECODE_RA_EVAL_FAMILY, STAGE6_KERNEL_ABIS, - }; + use super::{stage6_kernel_abi, STAGE6_KERNEL_ABIS}; #[test] fn stage6_kernel_abi_contracts_cover_supported_relations() { @@ -2523,11 +2521,13 @@ mod tests { "stage6.bytecode_read_raf.eval.BytecodeRa_1".to_owned(), ], }]; - let (family_ref, family) = - stage6_bytecode_read_raf_eval_family_ref(&families, "STAGE6_INDEXED_EVAL_FAMILIES")?; - assert_eq!(family_ref, "STAGE6_INDEXED_EVAL_FAMILIES[0]"); + let plan = Stage6BytecodeReadRafEmitPlan::from_eval_families(&families)?; + assert_eq!( + plan.bytecode_ra_evals_ref, + "STAGE6_INDEXED_EVAL_FAMILIES[0]" + ); assert_eq!( - family.evals, + plan.bytecode_ra_evals.evals, vec![ "stage6.bytecode_read_raf.eval.BytecodeRa_2".to_owned(), "stage6.bytecode_read_raf.eval.BytecodeRa_0".to_owned(), @@ -2544,11 +2544,10 @@ mod tests { evals: vec!["stage6.other.eval.BytecodeRa_0".to_owned()], }]; - let error = - stage6_bytecode_read_raf_eval_family_ref(&families, "STAGE6_INDEXED_EVAL_FAMILIES") - .err() - .map(|error| error.to_string()) - .unwrap_or_default(); + let error = Stage6BytecodeReadRafEmitPlan::from_eval_families(&families) + .err() + .map(|error| error.to_string()) + .unwrap_or_default(); assert!(error.contains(&format!( "missing eval family `{STAGE6_BYTECODE_RA_EVAL_FAMILY}`" diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 99e984ce63..16eb0ca509 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -345,8 +345,33 @@ const STAGE6_BYTECODE_READ_RAF_PLAN: BytecodeReadRafPlan = BytecodeReadRafPlan { entry_lookup_table: "stage6.bytecode.entry.lookup_table", }; -pub(crate) fn emit_stage6_bytecode_read_raf_plan_constants(bytecode_ra_evals_ref: &str) -> String { - emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN, bytecode_ra_evals_ref) +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct Stage6BytecodeReadRafEmitPlan { + pub(crate) bytecode_ra_evals: IndexedEvalFamilyPlan, + pub(crate) bytecode_ra_evals_ref: String, +} + +impl Stage6BytecodeReadRafEmitPlan { + pub(crate) fn from_eval_families( + eval_families: &[IndexedEvalFamilyPlan], + ) -> Result { + let (bytecode_ra_evals_ref, bytecode_ra_evals) = stage6_bytecode_read_raf_eval_family_ref( + eval_families, + "STAGE6_INDEXED_EVAL_FAMILIES", + )?; + Ok(Self { + bytecode_ra_evals: bytecode_ra_evals.clone(), + bytecode_ra_evals_ref, + }) + } + + pub(crate) fn emit_runtime_constants(&self) -> String { + emit_bytecode_read_raf_plan(&STAGE6_BYTECODE_READ_RAF_PLAN, &self.bytecode_ra_evals_ref) + } + + pub(crate) fn relation_output_plan(&self) -> Stage6BytecodeReadRafRelationOutputPlan { + STAGE6_BYTECODE_READ_RAF_PLAN.relation_output_plan(&self.bytecode_ra_evals) + } } #[cfg(test)] @@ -354,12 +379,6 @@ pub(crate) fn stage6_bytecode_read_raf_output_contribution_symbol() -> &'static STAGE6_BYTECODE_READ_RAF_PLAN.output_contribution } -pub(crate) fn stage6_bytecode_read_raf_relation_output_plan( - bytecode_ra_evals: &IndexedEvalFamilyPlan, -) -> Stage6BytecodeReadRafRelationOutputPlan { - STAGE6_BYTECODE_READ_RAF_PLAN.relation_output_plan(bytecode_ra_evals) -} - #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Stage6BytecodeReadRafRelationOutputPlan { pub(crate) field_exprs: Vec, @@ -506,7 +525,7 @@ fn emit_bytecode_read_raf_plan(plan: &BytecodeReadRafPlan, bytecode_ra_evals_ref source } -pub(crate) fn stage6_bytecode_read_raf_eval_family_ref<'a>( +fn stage6_bytecode_read_raf_eval_family_ref<'a>( eval_families: &'a [IndexedEvalFamilyPlan], families_const: &str, ) -> Result<(String, &'a IndexedEvalFamilyPlan), EmitError> { @@ -612,11 +631,9 @@ mod tests { use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use super::{ - emit_stage6_bytecode_read_raf_plan_constants, stage6_bytecode_read_raf_eval_family_ref, - stage6_bytecode_read_raf_output_contribution_symbol, - stage6_bytecode_read_raf_relation_output_plan, BytecodeFlag, BytecodeOutputTermPlan, - BytecodeReadRafTermPlan, BytecodeRegister, STAGE6_BYTECODE_RA_EVAL_FAMILY, - STAGE6_BYTECODE_READ_RAF_PLAN, + stage6_bytecode_read_raf_output_contribution_symbol, BytecodeFlag, BytecodeOutputTermPlan, + BytecodeReadRafTermPlan, BytecodeRegister, Stage6BytecodeReadRafEmitPlan, + STAGE6_BYTECODE_RA_EVAL_FAMILY, STAGE6_BYTECODE_READ_RAF_PLAN, }; fn bytecode_ra_evals() -> IndexedEvalFamilyPlan { @@ -723,9 +740,11 @@ mod tests { } #[test] - fn stage6_bytecode_relation_output_plan_uses_point_derived_contribution() { - let bytecode_ra_evals = bytecode_ra_evals(); - let output_plan = stage6_bytecode_read_raf_relation_output_plan(&bytecode_ra_evals); + fn stage6_bytecode_relation_output_plan_uses_point_derived_contribution( + ) -> Result<(), EmitError> { + let output_plan = + Stage6BytecodeReadRafEmitPlan::from_eval_families(&[bytecode_ra_evals()])? + .relation_output_plan(); let claim = output_plan.claim; assert_eq!(claim.relation, "jolt.stage6.bytecode_read_raf"); @@ -769,12 +788,13 @@ mod tests { "stage6.bytecode_read_raf.output.product.BytecodeRa".to_owned() ] ); + Ok(()) } #[test] - fn stage6_bytecode_plan_renderer_emits_stage67_constants() { - let source = - emit_stage6_bytecode_read_raf_plan_constants("STAGE6_INDEXED_EVAL_FAMILIES[0]"); + fn stage6_bytecode_plan_renderer_emits_stage67_constants() -> Result<(), EmitError> { + let source = Stage6BytecodeReadRafEmitPlan::from_eval_families(&[bytecode_ra_evals()])? + .emit_runtime_constants(); assert!(source.contains("const STAGE6_BYTECODE_STAGE1_TERMS")); assert!(source.contains("Stage67BytecodeTermPlan::LookupTable { gamma_base: 2 }")); @@ -790,16 +810,22 @@ mod tests { .contains("output_contribution: \"stage6.bytecode_read_raf.output.contribution\"")); assert!(source.contains("bytecode_ra_evals: &STAGE6_INDEXED_EVAL_FAMILIES[0]")); assert!(source.contains("pub const STAGE6_BYTECODE_PLAN: Stage67BytecodeReadRafPlan")); + Ok(()) } #[test] fn stage6_bytecode_plan_references_indexed_eval_family_row() -> Result<(), EmitError> { let families = [bytecode_ra_evals()]; - let (family_ref, family) = - stage6_bytecode_read_raf_eval_family_ref(&families, "STAGE6_INDEXED_EVAL_FAMILIES")?; + let plan = Stage6BytecodeReadRafEmitPlan::from_eval_families(&families)?; - assert_eq!(family_ref, "STAGE6_INDEXED_EVAL_FAMILIES[0]"); - assert_eq!(family.symbol, STAGE6_BYTECODE_RA_EVAL_FAMILY); + assert_eq!( + plan.bytecode_ra_evals_ref, + "STAGE6_INDEXED_EVAL_FAMILIES[0]" + ); + assert_eq!( + plan.bytecode_ra_evals.symbol, + STAGE6_BYTECODE_RA_EVAL_FAMILY + ); Ok(()) } } diff --git a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs index ab0463dbc9..015f9d78b4 100644 --- a/crates/bolt/src/protocols/jolt/verifier_eval_families.rs +++ b/crates/bolt/src/protocols/jolt/verifier_eval_families.rs @@ -24,13 +24,6 @@ impl IndexedEvalFamilyPlan { Ok(Self { symbol, evals }) } - pub(crate) fn find<'a>( - families: &'a [Self], - symbol: &str, - ) -> Result<&'a IndexedEvalFamilyPlan, EmitError> { - Self::find_with_index(families, symbol).map(|(_, family)| family) - } - pub(crate) fn find_with_index<'a>( families: &'a [Self], symbol: &str, @@ -119,8 +112,8 @@ mod tests { }; #[test] - fn find_rejects_missing_families() { - let error = IndexedEvalFamilyPlan::find(&[], "stage.eval.LookupTableFlag") + fn find_with_index_rejects_missing_families() { + let error = IndexedEvalFamilyPlan::find_with_index(&[], "stage.eval.LookupTableFlag") .err() .map(|error| error.to_string()) .unwrap_or_default(); @@ -145,7 +138,7 @@ mod tests { } #[test] - fn find_rejects_duplicate_families() { + fn find_with_index_rejects_duplicate_families() { let families = [ IndexedEvalFamilyPlan { symbol: "stage.eval.BytecodeRa".to_owned(), @@ -157,7 +150,7 @@ mod tests { }, ]; - let error = IndexedEvalFamilyPlan::find(&families, "stage.eval.BytecodeRa") + let error = IndexedEvalFamilyPlan::find_with_index(&families, "stage.eval.BytecodeRa") .err() .map(|error| error.to_string()) .unwrap_or_default(); diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index fb8392b158..490e0591ba 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -6,6 +6,8 @@ use crate::protocols::jolt::rust_target_plan::{ ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, ProgramStepKind, RustTargetPlanError, ScalarExprKind, SumcheckPointOrder, TranscriptSqueezeKind, }; +use crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionReadRafEmitPlan; +use crate::protocols::jolt::stage6_bytecode_read_raf_plan::Stage6BytecodeReadRafEmitPlan; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_opening_rows::{ CpuOpeningBatchPlan, CpuOpeningClaimEqualityPlan, CpuOpeningClaimPlan, @@ -277,6 +279,41 @@ pub(crate) struct VerifierOpeningBatchPlan { pub(crate) claim_operands: Vec, } +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub(crate) struct VerifierRelationLocalInputPlans { + stage5_instruction_read_raf: Option, + stage6_bytecode_read_raf: Option, +} + +impl VerifierRelationLocalInputPlans { + pub(crate) fn set_stage5_instruction_read_raf( + &mut self, + plan: Stage5InstructionReadRafEmitPlan, + ) { + self.stage5_instruction_read_raf = Some(plan); + } + + pub(crate) fn stage5_instruction_read_raf( + &self, + ) -> Result<&Stage5InstructionReadRafEmitPlan, EmitError> { + self.stage5_instruction_read_raf + .as_ref() + .ok_or_else(|| EmitError::new("missing Stage 5 instruction read-RAF local-input plan")) + } + + pub(crate) fn set_stage6_bytecode_read_raf(&mut self, plan: Stage6BytecodeReadRafEmitPlan) { + self.stage6_bytecode_read_raf = Some(plan); + } + + pub(crate) fn stage6_bytecode_read_raf( + &self, + ) -> Result<&Stage6BytecodeReadRafEmitPlan, EmitError> { + self.stage6_bytecode_read_raf + .as_ref() + .ok_or_else(|| EmitError::new("missing Stage 6 bytecode read-RAF local-input plan")) + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierStagePlan { pub(crate) steps: Vec, @@ -297,6 +334,7 @@ pub(crate) struct VerifierStagePlan { pub(crate) relation_output_product_families: Vec, pub(crate) relation_output_function_families: Vec, pub(crate) relation_outputs: Vec, + pub(crate) relation_local_inputs: VerifierRelationLocalInputPlans, pub(crate) point_exprs: Vec, pub(crate) opening_claims: Vec, pub(crate) opening_equalities: Vec, @@ -1171,6 +1209,7 @@ where relation_output_product_families: source.relation_output_product_families().to_vec(), relation_output_function_families: source.relation_output_function_families().to_vec(), relation_outputs: source.relation_outputs().to_vec(), + relation_local_inputs: VerifierRelationLocalInputPlans::default(), point_exprs: source.point_exprs(), opening_claims: source .opening_claims() From db2cf6ae83313a11523405d6db465bfa6dcbec80 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 07:49:17 -0600 Subject: [PATCH 142/171] refactor(verifier): row local input plans --- .../src/protocols/jolt/emit/rust/stage5.rs | 4 +- .../src/protocols/jolt/emit/rust/stage6.rs | 4 +- .../bolt/src/protocols/jolt/verifier_plan.rs | 78 ++++++++++++++++--- 3 files changed, 71 insertions(+), 15 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 588ae841a6..abe6555d47 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -386,9 +386,9 @@ impl Stage5CpuProgram { fn plan_verifier(&self) -> Result { let mut plan = verifier_plan::stage_plan_from_cpu_sources(self)?; - plan.relation_local_inputs.set_stage5_instruction_read_raf( + plan.relation_local_inputs.add_stage5_instruction_read_raf( Stage5InstructionReadRafEmitPlan::from_eval_families(&plan.indexed_eval_families)?, - ); + )?; Ok(plan) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 051b5a5941..ccfa080e7b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -406,9 +406,9 @@ impl Stage6CpuProgram { fn plan_verifier(&self) -> Result { let mut plan = verifier_plan::stage_plan_from_cpu_sources(self)?; - plan.relation_local_inputs.set_stage6_bytecode_read_raf( + plan.relation_local_inputs.add_stage6_bytecode_read_raf( Stage6BytecodeReadRafEmitPlan::from_eval_families(&plan.indexed_eval_families)?, - ); + )?; Ok(plan) } diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 490e0591ba..b0c6ed3315 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -279,39 +279,95 @@ pub(crate) struct VerifierOpeningBatchPlan { pub(crate) claim_operands: Vec, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum VerifierRelationLocalInputKind { + Stage5InstructionReadRaf, + Stage6BytecodeReadRaf, +} + +impl VerifierRelationLocalInputKind { + fn label(self) -> &'static str { + match self { + Self::Stage5InstructionReadRaf => "Stage 5 instruction read-RAF", + Self::Stage6BytecodeReadRaf => "Stage 6 bytecode read-RAF", + } + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum VerifierRelationLocalInputPlan { + Stage5InstructionReadRaf(Stage5InstructionReadRafEmitPlan), + Stage6BytecodeReadRaf(Stage6BytecodeReadRafEmitPlan), +} + +impl VerifierRelationLocalInputPlan { + fn kind(&self) -> VerifierRelationLocalInputKind { + match self { + Self::Stage5InstructionReadRaf(_) => { + VerifierRelationLocalInputKind::Stage5InstructionReadRaf + } + Self::Stage6BytecodeReadRaf(_) => VerifierRelationLocalInputKind::Stage6BytecodeReadRaf, + } + } +} + #[derive(Clone, Debug, Default, PartialEq, Eq)] pub(crate) struct VerifierRelationLocalInputPlans { - stage5_instruction_read_raf: Option, - stage6_bytecode_read_raf: Option, + rows: Vec, } impl VerifierRelationLocalInputPlans { - pub(crate) fn set_stage5_instruction_read_raf( + pub(crate) fn add_stage5_instruction_read_raf( &mut self, plan: Stage5InstructionReadRafEmitPlan, - ) { - self.stage5_instruction_read_raf = Some(plan); + ) -> Result<(), EmitError> { + self.push(VerifierRelationLocalInputPlan::Stage5InstructionReadRaf( + plan, + )) } pub(crate) fn stage5_instruction_read_raf( &self, ) -> Result<&Stage5InstructionReadRafEmitPlan, EmitError> { - self.stage5_instruction_read_raf - .as_ref() + self.rows + .iter() + .find_map(|row| match row { + VerifierRelationLocalInputPlan::Stage5InstructionReadRaf(plan) => Some(plan), + VerifierRelationLocalInputPlan::Stage6BytecodeReadRaf(_) => None, + }) .ok_or_else(|| EmitError::new("missing Stage 5 instruction read-RAF local-input plan")) } - pub(crate) fn set_stage6_bytecode_read_raf(&mut self, plan: Stage6BytecodeReadRafEmitPlan) { - self.stage6_bytecode_read_raf = Some(plan); + pub(crate) fn add_stage6_bytecode_read_raf( + &mut self, + plan: Stage6BytecodeReadRafEmitPlan, + ) -> Result<(), EmitError> { + self.push(VerifierRelationLocalInputPlan::Stage6BytecodeReadRaf(plan)) } pub(crate) fn stage6_bytecode_read_raf( &self, ) -> Result<&Stage6BytecodeReadRafEmitPlan, EmitError> { - self.stage6_bytecode_read_raf - .as_ref() + self.rows + .iter() + .find_map(|row| match row { + VerifierRelationLocalInputPlan::Stage5InstructionReadRaf(_) => None, + VerifierRelationLocalInputPlan::Stage6BytecodeReadRaf(plan) => Some(plan), + }) .ok_or_else(|| EmitError::new("missing Stage 6 bytecode read-RAF local-input plan")) } + + fn push(&mut self, row: VerifierRelationLocalInputPlan) -> Result<(), EmitError> { + let kind = row.kind(); + if self.rows.iter().any(|existing| existing.kind() == kind) { + return Err(EmitError::new(format!( + "duplicate {} local-input plan", + kind.label() + ))); + } + self.rows.push(row); + Ok(()) + } } #[derive(Clone, Debug, PartialEq, Eq)] From 522e0d496fd033877b63c30117e6428c58e0bf43 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 07:59:47 -0600 Subject: [PATCH 143/171] refactor(verifier): validate local scalar plans --- .../jolt/stage5_instruction_read_raf_plan.rs | 4 ++ .../jolt/stage6_bytecode_read_raf_plan.rs | 8 +++ .../bolt/src/protocols/jolt/verifier_plan.rs | 30 +++++++++--- .../jolt/verifier_relation_outputs.rs | 49 ++++++++++++++++++- 4 files changed, 84 insertions(+), 7 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 730026123e..c1dc433dc7 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -212,6 +212,10 @@ impl Stage5InstructionReadRafEmitPlan { }, } } + + pub(crate) fn local_scalar_symbols(&self) -> impl Iterator { + self.point_values.iter().map(|value| &value.symbol) + } } #[derive(Clone, Debug, PartialEq, Eq)] diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 16eb0ca509..0c3806ebfb 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -372,6 +372,14 @@ impl Stage6BytecodeReadRafEmitPlan { pub(crate) fn relation_output_plan(&self) -> Stage6BytecodeReadRafRelationOutputPlan { STAGE6_BYTECODE_READ_RAF_PLAN.relation_output_plan(&self.bytecode_ra_evals) } + + pub(crate) fn local_scalar_symbols() -> impl Iterator { + STAGE6_BYTECODE_READ_RAF_PLAN + .output_terms + .iter() + .copied() + .map(BytecodeOutputTermPlan::symbol) + } } #[cfg(test)] diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index b0c6ed3315..7bb383c8f6 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -309,6 +309,22 @@ impl VerifierRelationLocalInputPlan { Self::Stage6BytecodeReadRaf(_) => VerifierRelationLocalInputKind::Stage6BytecodeReadRaf, } } + + fn insert_scalar_sources(&self, values: &mut VerifierScalarSourceSet) { + match self { + Self::Stage5InstructionReadRaf(plan) => { + values.extend( + plan.local_scalar_symbols(), + VerifierScalarSourceKind::RelationOutputLocal, + ); + } + Self::Stage6BytecodeReadRaf(_) => { + for symbol in Stage6BytecodeReadRafEmitPlan::local_scalar_symbols() { + values.insert(symbol, VerifierScalarSourceKind::RelationOutputLocal); + } + } + } + } } #[derive(Clone, Debug, Default, PartialEq, Eq)] @@ -368,6 +384,12 @@ impl VerifierRelationLocalInputPlans { self.rows.push(row); Ok(()) } + + fn insert_scalar_sources(&self, values: &mut VerifierScalarSourceSet) { + for row in &self.rows { + row.insert_scalar_sources(values); + } + } } #[derive(Clone, Debug, PartialEq, Eq)] @@ -446,12 +468,8 @@ impl VerifierStagePlan { self.scalar_exprs.iter().map(|expr| &expr.symbol), VerifierScalarSourceKind::ScalarExpr, ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|claim| claim.local_scalars.iter()), - VerifierScalarSourceKind::RelationOutputLocal, - ); + self.relation_local_inputs + .insert_scalar_sources(&mut values); values.extend( self.sumcheck_evals.iter().map(|eval| &eval.symbol), VerifierScalarSourceKind::SumcheckEval, diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 1c15e6adbc..94fed5fcf7 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -1443,6 +1443,14 @@ pub fn verify_relation_outputs( claim.relation, claim.expected_output ))); } + for local_scalar in &claim.local_scalars { + if !field_values.contains(local_scalar) { + return Err(EmitError::new(format!( + "{stage} relation output for @{} references missing local scalar @{}", + claim.relation, local_scalar + ))); + } + } } Ok(()) } @@ -1522,7 +1530,7 @@ mod tests { resolve_relation_outputs, verify_relation_outputs, FieldExprDependencies, RelationOutputAst, RelationOutputEvalFamilyItemTermPlan, RelationOutputEvalFamilyPlan, RelationOutputEvalFamilySharedTermPlan, RelationOutputFunctionFamilyPlan, - RelationOutputFunctionFamilyTermPlan, RelationOutputFunctionKind, + RelationOutputFunctionFamilyTermPlan, RelationOutputFunctionKind, RelationOutputPlan, RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, RelationOutputVerification, StructuredPolynomialEvalPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, @@ -1804,4 +1812,43 @@ mod tests { )); Ok(()) } + + #[test] + fn relation_output_verification_requires_planned_local_scalars() -> Result<(), EmitError> { + let mut field_values = VerifierScalarSourceSet::default(); + field_values.insert("claim", VerifierScalarSourceKind::FieldExpr); + let point_values = VerifierPointSourceSet::default(); + let relations = BTreeSet::from(["relation".to_owned()]); + let relation_outputs = [RelationOutputPlan { + relation: "relation".to_owned(), + local_scalars: vec!["local.scalar".to_owned()], + expected_output: "claim".to_owned(), + }]; + + let error = match verify_relation_outputs( + "stage", + RelationOutputVerification { + relation_output_values: &[], + relation_output_eval_families: &[], + relation_output_product_families: &[], + relation_output_function_families: &[], + relation_outputs: &relation_outputs, + relations: &relations, + field_values: &field_values, + point_values: &point_values, + }, + ) { + Ok(()) => { + return Err(EmitError::new( + "unplanned local scalar should fail relation output verification", + )); + } + Err(error) => error, + }; + + assert!(error.to_string().contains( + "stage relation output for @relation references missing local scalar @local.scalar" + )); + Ok(()) + } } From cdb954be2c4ebede1b27868c1d071ad78bee7366 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 08:06:00 -0600 Subject: [PATCH 144/171] refactor(verifier): name stage5 local scalars --- .../src/protocols/jolt/emit/rust/stage5.rs | 4 +- .../jolt/stage5_instruction_read_raf_plan.rs | 94 ++++----- .../jolt/verifier_jolt_relations.rs.template | 28 +-- crates/bolt/tests/commitment_ir.rs | 4 +- .../src/stages/jolt_relations.rs | 29 +-- crates/jolt-verifier/src/stages/stage5.rs | 186 +++++++++--------- 6 files changed, 173 insertions(+), 172 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index abe6555d47..e267a5f259 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -936,7 +936,7 @@ impl Stage5CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::find_plan;\n\ - use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan};\n\ + use super::jolt_relations::{evaluate_stage5_instruction_read_raf_local_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafLocalScalarKind, Stage5InstructionReadRafLocalScalarPlan};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" @@ -2239,7 +2239,7 @@ fn stage5_relation_output_inputs<'a>( Ok(bolt_verifier_runtime::RelationOutputInputs { scalars: bolt_verifier_runtime::select_named_scalars( relation_output.local_scalars, - evaluate_stage5_instruction_read_raf_point_scalars( + evaluate_stage5_instruction_read_raf_local_scalars( &program.instruction_read_raf_plan, local_point, )?, diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index c1dc433dc7..96eaa52b5a 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -22,7 +22,7 @@ pub(crate) struct Stage5InstructionReadRafEmitPlan { pub(crate) instruction_ra_evals_ref: String, pub(crate) raf_flag_eval: String, pub(crate) gamma: String, - pub(crate) point_values: Vec, + pub(crate) local_scalars: Vec, pub(crate) log_k: usize, } @@ -40,7 +40,7 @@ impl Stage5InstructionReadRafEmitPlan { Ok(Self { point: "stage5.instruction_read_raf.instance".to_owned(), lookup_output_point: "stage5.input.stage2.instruction.LookupOutput".to_owned(), - point_values: point_value_plans(table_flag_evals.evals.len()), + local_scalars: local_scalar_plans(table_flag_evals.evals.len()), table_flag_evals: table_flag_evals.clone(), table_flag_evals_ref: indexed_eval_family_ref(table_flag_evals_index), instruction_ra_evals: instruction_ra_evals.clone(), @@ -53,7 +53,7 @@ impl Stage5InstructionReadRafEmitPlan { pub(crate) fn emit_runtime_constants(&self) -> String { let mut source = String::new(); - source.push_str(&emit_point_value_constants(&self.point_values)); + source.push_str(&emit_local_scalar_constants(&self.local_scalars)); push_format( &mut source, format_args!( @@ -64,7 +64,7 @@ impl Stage5InstructionReadRafEmitPlan { \x20 instruction_ra_evals: {},\n\ \x20 raf_flag_eval: {},\n\ \x20 gamma: {},\n\ - \x20 point_values: STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES,\n\ + \x20 local_scalars: STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS,\n\ \x20 log_k: {},\n\ }};\n\n", rust_str(&self.point), @@ -99,9 +99,9 @@ impl Stage5InstructionReadRafEmitPlan { }, }; - let left = "stage5.instruction_read_raf.point_value.LeftLookupOperand".to_owned(); - let right = "stage5.instruction_read_raf.point_value.RightLookupOperand".to_owned(); - let identity = "stage5.instruction_read_raf.point_value.Identity".to_owned(); + let left = "stage5.instruction_read_raf.local_scalar.LeftLookupOperand".to_owned(); + let right = "stage5.instruction_read_raf.local_scalar.RightLookupOperand".to_owned(); + let identity = "stage5.instruction_read_raf.local_scalar.Identity".to_owned(); let gamma_right = format!("{PREFIX}.term.GammaRightLookupOperand"); let left_plus_gamma_right = format!("{PREFIX}.partial.LeftPlusGammaRight"); let raf_flag_left_plus_gamma_right = format!("{PREFIX}.term.RafFlagLeftPlusGammaRight"); @@ -124,7 +124,7 @@ impl Stage5InstructionReadRafEmitPlan { .evals .iter() .zip( - self.point_values + self.local_scalars .iter() .filter(|value| value.is_lookup_table()), ) @@ -204,7 +204,7 @@ impl Stage5InstructionReadRafEmitPlan { claim: RelationOutputPlan { relation: "jolt.stage5.instruction_read_raf".to_owned(), local_scalars: self - .point_values + .local_scalars .iter() .map(|value| value.symbol.clone()) .collect(), @@ -214,14 +214,14 @@ impl Stage5InstructionReadRafEmitPlan { } pub(crate) fn local_scalar_symbols(&self) -> impl Iterator { - self.point_values.iter().map(|value| &value.symbol) + self.local_scalars.iter().map(|value| &value.symbol) } } #[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct Stage5InstructionReadRafPointValueEmitPlan { +pub(crate) struct Stage5InstructionReadRafLocalScalarEmitPlan { pub(crate) symbol: String, - pub(crate) kind: Stage5InstructionReadRafPointValueKind, + pub(crate) kind: Stage5InstructionReadRafLocalScalarKind, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -238,42 +238,42 @@ pub(crate) struct Stage5InstructionReadRafOutputFieldExprPlan { pub(crate) operands: Vec, } -impl Stage5InstructionReadRafPointValueEmitPlan { +impl Stage5InstructionReadRafLocalScalarEmitPlan { pub(crate) fn is_lookup_table(&self) -> bool { matches!( self.kind, - Stage5InstructionReadRafPointValueKind::LookupTable { .. } + Stage5InstructionReadRafLocalScalarKind::LookupTable { .. } ) } } #[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) enum Stage5InstructionReadRafPointValueKind { +pub(crate) enum Stage5InstructionReadRafLocalScalarKind { LookupTable { index: usize }, LeftOperand, RightOperand, Identity, } -fn point_value_plans(table_count: usize) -> Vec { +fn local_scalar_plans(table_count: usize) -> Vec { let mut values = (0..table_count) - .map(|index| Stage5InstructionReadRafPointValueEmitPlan { - symbol: format!("stage5.instruction_read_raf.point_value.LookupTable_{index}"), - kind: Stage5InstructionReadRafPointValueKind::LookupTable { index }, + .map(|index| Stage5InstructionReadRafLocalScalarEmitPlan { + symbol: format!("stage5.instruction_read_raf.local_scalar.LookupTable_{index}"), + kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index }, }) .collect::>(); values.extend([ - Stage5InstructionReadRafPointValueEmitPlan { - symbol: "stage5.instruction_read_raf.point_value.LeftLookupOperand".to_owned(), - kind: Stage5InstructionReadRafPointValueKind::LeftOperand, + Stage5InstructionReadRafLocalScalarEmitPlan { + symbol: "stage5.instruction_read_raf.local_scalar.LeftLookupOperand".to_owned(), + kind: Stage5InstructionReadRafLocalScalarKind::LeftOperand, }, - Stage5InstructionReadRafPointValueEmitPlan { - symbol: "stage5.instruction_read_raf.point_value.RightLookupOperand".to_owned(), - kind: Stage5InstructionReadRafPointValueKind::RightOperand, + Stage5InstructionReadRafLocalScalarEmitPlan { + symbol: "stage5.instruction_read_raf.local_scalar.RightLookupOperand".to_owned(), + kind: Stage5InstructionReadRafLocalScalarKind::RightOperand, }, - Stage5InstructionReadRafPointValueEmitPlan { - symbol: "stage5.instruction_read_raf.point_value.Identity".to_owned(), - kind: Stage5InstructionReadRafPointValueKind::Identity, + Stage5InstructionReadRafLocalScalarEmitPlan { + symbol: "stage5.instruction_read_raf.local_scalar.Identity".to_owned(), + kind: Stage5InstructionReadRafLocalScalarKind::Identity, }, ]); values @@ -291,36 +291,36 @@ fn output_field_expr( } } -fn emit_point_value_constants(values: &[Stage5InstructionReadRafPointValueEmitPlan]) -> String { +fn emit_local_scalar_constants(values: &[Stage5InstructionReadRafLocalScalarEmitPlan]) -> String { let values = values .iter() .map(|value| { format!( - " Stage5InstructionReadRafPointValuePlan {{ symbol: {}, kind: {} }},", + " Stage5InstructionReadRafLocalScalarPlan {{ symbol: {}, kind: {} }},", rust_str(&value.symbol), - point_value_kind_expr(&value.kind), + local_scalar_kind_expr(&value.kind), ) }) .collect::>() .join("\n"); format!( - "pub const STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES: &[Stage5InstructionReadRafPointValuePlan] = &[\n{values}\n];\n\n" + "pub const STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS: &[Stage5InstructionReadRafLocalScalarPlan] = &[\n{values}\n];\n\n" ) } -fn point_value_kind_expr(kind: &Stage5InstructionReadRafPointValueKind) -> String { +fn local_scalar_kind_expr(kind: &Stage5InstructionReadRafLocalScalarKind) -> String { match kind { - Stage5InstructionReadRafPointValueKind::LookupTable { index } => { - format!("Stage5InstructionReadRafPointValueKind::LookupTable {{ index: {index} }}") + Stage5InstructionReadRafLocalScalarKind::LookupTable { index } => { + format!("Stage5InstructionReadRafLocalScalarKind::LookupTable {{ index: {index} }}") } - Stage5InstructionReadRafPointValueKind::LeftOperand => { - "Stage5InstructionReadRafPointValueKind::LeftOperand".to_owned() + Stage5InstructionReadRafLocalScalarKind::LeftOperand => { + "Stage5InstructionReadRafLocalScalarKind::LeftOperand".to_owned() } - Stage5InstructionReadRafPointValueKind::RightOperand => { - "Stage5InstructionReadRafPointValueKind::RightOperand".to_owned() + Stage5InstructionReadRafLocalScalarKind::RightOperand => { + "Stage5InstructionReadRafLocalScalarKind::RightOperand".to_owned() } - Stage5InstructionReadRafPointValueKind::Identity => { - "Stage5InstructionReadRafPointValueKind::Identity".to_owned() + Stage5InstructionReadRafLocalScalarKind::Identity => { + "Stage5InstructionReadRafLocalScalarKind::Identity".to_owned() } } } @@ -444,11 +444,11 @@ mod tests { assert_eq!( output_plan.claim.local_scalars, vec![ - "stage5.instruction_read_raf.point_value.LookupTable_0".to_owned(), - "stage5.instruction_read_raf.point_value.LookupTable_1".to_owned(), - "stage5.instruction_read_raf.point_value.LeftLookupOperand".to_owned(), - "stage5.instruction_read_raf.point_value.RightLookupOperand".to_owned(), - "stage5.instruction_read_raf.point_value.Identity".to_owned(), + "stage5.instruction_read_raf.local_scalar.LookupTable_0".to_owned(), + "stage5.instruction_read_raf.local_scalar.LookupTable_1".to_owned(), + "stage5.instruction_read_raf.local_scalar.LeftLookupOperand".to_owned(), + "stage5.instruction_read_raf.local_scalar.RightLookupOperand".to_owned(), + "stage5.instruction_read_raf.local_scalar.Identity".to_owned(), ] ); assert!(output_plan.field_exprs.iter().any(|expr| { @@ -456,7 +456,7 @@ mod tests { && expr.formula == "field.mul" && expr.operands == vec![ - "stage5.instruction_read_raf.point_value.LookupTable_0".to_owned(), + "stage5.instruction_read_raf.local_scalar.LookupTable_0".to_owned(), "stage5.instruction_read_raf.eval.LookupTableFlag_0".to_owned(), ] })); diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index f95a8d1c76..854bd9dd1b 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -94,18 +94,18 @@ pub struct Stage5InstructionReadRafPlan { pub instruction_ra_evals: &'static NamedEvalFamilyPlan, pub raf_flag_eval: &'static str, pub gamma: &'static str, - pub point_values: &'static [Stage5InstructionReadRafPointValuePlan], + pub local_scalars: &'static [Stage5InstructionReadRafLocalScalarPlan], pub log_k: usize, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage5InstructionReadRafPointValuePlan { +pub struct Stage5InstructionReadRafLocalScalarPlan { pub symbol: &'static str, - pub kind: Stage5InstructionReadRafPointValueKind, + pub kind: Stage5InstructionReadRafLocalScalarKind, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Stage5InstructionReadRafPointValueKind { +pub enum Stage5InstructionReadRafLocalScalarKind { LookupTable { index: usize }, LeftOperand, RightOperand, @@ -224,14 +224,14 @@ pub trait Stage67BytecodeEntry { fn is_noop(&self) -> bool; } -pub fn evaluate_stage5_instruction_read_raf_point_scalars( +pub fn evaluate_stage5_instruction_read_raf_local_scalars( plan: &Stage5InstructionReadRafPlan, local_point: &[Fr], ) -> Result>, RuntimePlanError> { let (r_address_prime, _) = instruction_read_raf_point_parts(plan, local_point)?; - let mut scalars = Vec::with_capacity(plan.point_values.len()); - for value in plan.point_values { - let scalar = evaluate_stage5_instruction_read_raf_point_value(value.kind, r_address_prime)?; + let mut scalars = Vec::with_capacity(plan.local_scalars.len()); + for value in plan.local_scalars { + let scalar = evaluate_stage5_instruction_read_raf_local_scalar(value.kind, r_address_prime)?; scalars.push(NamedScalar { symbol: value.symbol, value: scalar, @@ -240,13 +240,13 @@ pub fn evaluate_stage5_instruction_read_raf_point_scalars( Ok(scalars) } -fn evaluate_stage5_instruction_read_raf_point_value( - kind: Stage5InstructionReadRafPointValueKind, +fn evaluate_stage5_instruction_read_raf_local_scalar( + kind: Stage5InstructionReadRafLocalScalarKind, r_address_prime: &[Fr], ) -> Result { const XLEN: usize = 64; Ok(match kind { - Stage5InstructionReadRafPointValueKind::LookupTable { index } => { + Stage5InstructionReadRafLocalScalarKind::LookupTable { index } => { let tables = LookupTableKind::::all(); let table = tables .get(index) @@ -257,13 +257,13 @@ fn evaluate_stage5_instruction_read_raf_point_value( })?; table.evaluate_mle::(r_address_prime) } - Stage5InstructionReadRafPointValueKind::LeftOperand => { + Stage5InstructionReadRafLocalScalarKind::LeftOperand => { operand_polynomial_eval(r_address_prime, true)? } - Stage5InstructionReadRafPointValueKind::RightOperand => { + Stage5InstructionReadRafLocalScalarKind::RightOperand => { operand_polynomial_eval(r_address_prime, false)? } - Stage5InstructionReadRafPointValueKind::Identity => { + Stage5InstructionReadRafLocalScalarKind::Identity => { IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime) } }) diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index f756b059b5..f5867a0e02 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1467,13 +1467,13 @@ fn stage5_rust_targets_extract_and_compile() { .contains("relation: Some(Stage5RelationKind::Stage5Batched)")); assert!(verifier_source .source - .contains("evaluate_stage5_instruction_read_raf_point_scalars")); + .contains("evaluate_stage5_instruction_read_raf_local_scalars")); assert!(verifier_source .source .contains("Stage5RelationKind::Stage5InstructionReadRaf")); assert!(verifier_source .source - .contains("Stage5InstructionReadRafPointValueKind::LookupTable")); + .contains("Stage5InstructionReadRafLocalScalarKind::LookupTable")); assert!(!verifier_source .source .contains("expected_ram_ra_claim_reduction")); diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index f95a8d1c76..5210e92d38 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -94,18 +94,18 @@ pub struct Stage5InstructionReadRafPlan { pub instruction_ra_evals: &'static NamedEvalFamilyPlan, pub raf_flag_eval: &'static str, pub gamma: &'static str, - pub point_values: &'static [Stage5InstructionReadRafPointValuePlan], + pub local_scalars: &'static [Stage5InstructionReadRafLocalScalarPlan], pub log_k: usize, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage5InstructionReadRafPointValuePlan { +pub struct Stage5InstructionReadRafLocalScalarPlan { pub symbol: &'static str, - pub kind: Stage5InstructionReadRafPointValueKind, + pub kind: Stage5InstructionReadRafLocalScalarKind, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Stage5InstructionReadRafPointValueKind { +pub enum Stage5InstructionReadRafLocalScalarKind { LookupTable { index: usize }, LeftOperand, RightOperand, @@ -224,14 +224,15 @@ pub trait Stage67BytecodeEntry { fn is_noop(&self) -> bool; } -pub fn evaluate_stage5_instruction_read_raf_point_scalars( +pub fn evaluate_stage5_instruction_read_raf_local_scalars( plan: &Stage5InstructionReadRafPlan, local_point: &[Fr], ) -> Result>, RuntimePlanError> { let (r_address_prime, _) = instruction_read_raf_point_parts(plan, local_point)?; - let mut scalars = Vec::with_capacity(plan.point_values.len()); - for value in plan.point_values { - let scalar = evaluate_stage5_instruction_read_raf_point_value(value.kind, r_address_prime)?; + let mut scalars = Vec::with_capacity(plan.local_scalars.len()); + for value in plan.local_scalars { + let scalar = + evaluate_stage5_instruction_read_raf_local_scalar(value.kind, r_address_prime)?; scalars.push(NamedScalar { symbol: value.symbol, value: scalar, @@ -240,13 +241,13 @@ pub fn evaluate_stage5_instruction_read_raf_point_scalars( Ok(scalars) } -fn evaluate_stage5_instruction_read_raf_point_value( - kind: Stage5InstructionReadRafPointValueKind, +fn evaluate_stage5_instruction_read_raf_local_scalar( + kind: Stage5InstructionReadRafLocalScalarKind, r_address_prime: &[Fr], ) -> Result { const XLEN: usize = 64; Ok(match kind { - Stage5InstructionReadRafPointValueKind::LookupTable { index } => { + Stage5InstructionReadRafLocalScalarKind::LookupTable { index } => { let tables = LookupTableKind::::all(); let table = tables .get(index) @@ -257,13 +258,13 @@ fn evaluate_stage5_instruction_read_raf_point_value( })?; table.evaluate_mle::(r_address_prime) } - Stage5InstructionReadRafPointValueKind::LeftOperand => { + Stage5InstructionReadRafLocalScalarKind::LeftOperand => { operand_polynomial_eval(r_address_prime, true)? } - Stage5InstructionReadRafPointValueKind::RightOperand => { + Stage5InstructionReadRafLocalScalarKind::RightOperand => { operand_polynomial_eval(r_address_prime, false)? } - Stage5InstructionReadRafPointValueKind::Identity => { + Stage5InstructionReadRafLocalScalarKind::Identity => { IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime) } }) diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 35c32b79ee..e2f3ff752f 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::find_plan; -use super::jolt_relations::{evaluate_stage5_instruction_read_raf_point_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafPointValueKind, Stage5InstructionReadRafPointValuePlan}; +use super::jolt_relations::{evaluate_stage5_instruction_read_raf_local_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafLocalScalarKind, Stage5InstructionReadRafLocalScalarPlan}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -119,53 +119,53 @@ pub const STAGE5_FIELD_EXPRS: &[Stage5FieldExprPlan] = &[ Stage5FieldExprPlan { symbol: "stage5.ram_ra_claim_reduction.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.ram_ra_claim_reduction.output.eq_combined", "stage5.ram_ra_claim_reduction.eval.RamRa"] }, Stage5FieldExprPlan { symbol: "stage5.registers_val_evaluation.output.product.RdIncRdWa", kind: Stage5FieldExprKind::Mul, operands: &["stage5.registers_val_evaluation.eval.RdInc", "stage5.registers_val_evaluation.eval.RdWa"] }, Stage5FieldExprPlan { symbol: "stage5.registers_val_evaluation.output.claim_expr", kind: Stage5FieldExprKind::Mul, operands: &["stage5.registers_val_evaluation.output.product.RdIncRdWa", "stage5.registers_val_evaluation.output.lt.RegistersValCycle"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_0", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_1", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_2", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_3", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_4", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_5", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_6", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_7", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_8", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_9", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_10", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_11", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_12", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_13", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_14", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_15", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_16", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_17", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_18", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_19", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_20", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_21", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_22", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_23", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_24", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_25", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_26", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_27", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_28", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_29", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_30", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_31", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_32", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_33", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_34", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_35", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_36", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_37", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_38", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_39", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_40", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_0", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_0", "stage5.instruction_read_raf.eval.LookupTableFlag_0"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_1", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_1", "stage5.instruction_read_raf.eval.LookupTableFlag_1"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_2", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_2", "stage5.instruction_read_raf.eval.LookupTableFlag_2"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_3", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_3", "stage5.instruction_read_raf.eval.LookupTableFlag_3"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_4", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_4", "stage5.instruction_read_raf.eval.LookupTableFlag_4"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_5", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_5", "stage5.instruction_read_raf.eval.LookupTableFlag_5"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_6", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_6", "stage5.instruction_read_raf.eval.LookupTableFlag_6"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_7", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_7", "stage5.instruction_read_raf.eval.LookupTableFlag_7"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_8", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_8", "stage5.instruction_read_raf.eval.LookupTableFlag_8"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_9", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_9", "stage5.instruction_read_raf.eval.LookupTableFlag_9"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_10", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_10", "stage5.instruction_read_raf.eval.LookupTableFlag_10"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_11", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_11", "stage5.instruction_read_raf.eval.LookupTableFlag_11"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_12", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_12", "stage5.instruction_read_raf.eval.LookupTableFlag_12"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_13", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_13", "stage5.instruction_read_raf.eval.LookupTableFlag_13"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_14", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_14", "stage5.instruction_read_raf.eval.LookupTableFlag_14"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_15", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_15", "stage5.instruction_read_raf.eval.LookupTableFlag_15"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_16", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_16", "stage5.instruction_read_raf.eval.LookupTableFlag_16"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_17", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_17", "stage5.instruction_read_raf.eval.LookupTableFlag_17"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_18", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_18", "stage5.instruction_read_raf.eval.LookupTableFlag_18"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_19", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_19", "stage5.instruction_read_raf.eval.LookupTableFlag_19"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_20", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_20", "stage5.instruction_read_raf.eval.LookupTableFlag_20"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_21", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_21", "stage5.instruction_read_raf.eval.LookupTableFlag_21"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_22", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_22", "stage5.instruction_read_raf.eval.LookupTableFlag_22"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_23", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_23", "stage5.instruction_read_raf.eval.LookupTableFlag_23"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_24", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_24", "stage5.instruction_read_raf.eval.LookupTableFlag_24"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_25", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_25", "stage5.instruction_read_raf.eval.LookupTableFlag_25"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_26", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_26", "stage5.instruction_read_raf.eval.LookupTableFlag_26"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_27", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_27", "stage5.instruction_read_raf.eval.LookupTableFlag_27"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_28", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_28", "stage5.instruction_read_raf.eval.LookupTableFlag_28"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_29", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_29", "stage5.instruction_read_raf.eval.LookupTableFlag_29"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_30", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_30", "stage5.instruction_read_raf.eval.LookupTableFlag_30"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_31", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_31", "stage5.instruction_read_raf.eval.LookupTableFlag_31"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_32", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_32", "stage5.instruction_read_raf.eval.LookupTableFlag_32"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_33", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_33", "stage5.instruction_read_raf.eval.LookupTableFlag_33"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_34", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_34", "stage5.instruction_read_raf.eval.LookupTableFlag_34"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_35", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_35", "stage5.instruction_read_raf.eval.LookupTableFlag_35"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_36", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_36", "stage5.instruction_read_raf.eval.LookupTableFlag_36"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_37", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_37", "stage5.instruction_read_raf.eval.LookupTableFlag_37"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_38", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_38", "stage5.instruction_read_raf.eval.LookupTableFlag_38"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_39", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_39", "stage5.instruction_read_raf.eval.LookupTableFlag_39"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.LookupTableValue_40", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.local_scalar.LookupTable_40", "stage5.instruction_read_raf.eval.LookupTableFlag_40"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.product.LookupTableValues", kind: Stage5FieldExprKind::Sum, operands: &["stage5.instruction_read_raf.output.term.LookupTableValue_0", "stage5.instruction_read_raf.output.term.LookupTableValue_1", "stage5.instruction_read_raf.output.term.LookupTableValue_2", "stage5.instruction_read_raf.output.term.LookupTableValue_3", "stage5.instruction_read_raf.output.term.LookupTableValue_4", "stage5.instruction_read_raf.output.term.LookupTableValue_5", "stage5.instruction_read_raf.output.term.LookupTableValue_6", "stage5.instruction_read_raf.output.term.LookupTableValue_7", "stage5.instruction_read_raf.output.term.LookupTableValue_8", "stage5.instruction_read_raf.output.term.LookupTableValue_9", "stage5.instruction_read_raf.output.term.LookupTableValue_10", "stage5.instruction_read_raf.output.term.LookupTableValue_11", "stage5.instruction_read_raf.output.term.LookupTableValue_12", "stage5.instruction_read_raf.output.term.LookupTableValue_13", "stage5.instruction_read_raf.output.term.LookupTableValue_14", "stage5.instruction_read_raf.output.term.LookupTableValue_15", "stage5.instruction_read_raf.output.term.LookupTableValue_16", "stage5.instruction_read_raf.output.term.LookupTableValue_17", "stage5.instruction_read_raf.output.term.LookupTableValue_18", "stage5.instruction_read_raf.output.term.LookupTableValue_19", "stage5.instruction_read_raf.output.term.LookupTableValue_20", "stage5.instruction_read_raf.output.term.LookupTableValue_21", "stage5.instruction_read_raf.output.term.LookupTableValue_22", "stage5.instruction_read_raf.output.term.LookupTableValue_23", "stage5.instruction_read_raf.output.term.LookupTableValue_24", "stage5.instruction_read_raf.output.term.LookupTableValue_25", "stage5.instruction_read_raf.output.term.LookupTableValue_26", "stage5.instruction_read_raf.output.term.LookupTableValue_27", "stage5.instruction_read_raf.output.term.LookupTableValue_28", "stage5.instruction_read_raf.output.term.LookupTableValue_29", "stage5.instruction_read_raf.output.term.LookupTableValue_30", "stage5.instruction_read_raf.output.term.LookupTableValue_31", "stage5.instruction_read_raf.output.term.LookupTableValue_32", "stage5.instruction_read_raf.output.term.LookupTableValue_33", "stage5.instruction_read_raf.output.term.LookupTableValue_34", "stage5.instruction_read_raf.output.term.LookupTableValue_35", "stage5.instruction_read_raf.output.term.LookupTableValue_36", "stage5.instruction_read_raf.output.term.LookupTableValue_37", "stage5.instruction_read_raf.output.term.LookupTableValue_38", "stage5.instruction_read_raf.output.term.LookupTableValue_39", "stage5.instruction_read_raf.output.term.LookupTableValue_40"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaRightLookupOperand", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.point_value.RightLookupOperand"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.output.term.GammaRightLookupOperand"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaRightLookupOperand", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.local_scalar.RightLookupOperand"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.local_scalar.LeftLookupOperand", "stage5.instruction_read_raf.output.term.GammaRightLookupOperand"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.RafFlagLeftPlusGammaRight", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.eval.InstructionRafFlag", "stage5.instruction_read_raf.output.partial.LeftPlusGammaRight"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.NonRafLookupOperands", kind: Stage5FieldExprKind::Sub, operands: &["stage5.instruction_read_raf.output.partial.LeftPlusGammaRight", "stage5.instruction_read_raf.output.term.RafFlagLeftPlusGammaRight"] }, - Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaIdentity", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.point_value.Identity"] }, + Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaIdentity", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.local_scalar.Identity"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.RafFlagGammaIdentity", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.eval.InstructionRafFlag", "stage5.instruction_read_raf.output.term.GammaIdentity"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.partial.RafClaim", kind: Stage5FieldExprKind::Add, operands: &["stage5.instruction_read_raf.output.partial.NonRafLookupOperands", "stage5.instruction_read_raf.output.term.RafFlagGammaIdentity"] }, Stage5FieldExprPlan { symbol: "stage5.instruction_read_raf.output.term.GammaRafClaim", kind: Stage5FieldExprKind::Mul, operands: &["stage5.instruction_read_raf.gamma", "stage5.instruction_read_raf.output.partial.RafClaim"] }, @@ -262,51 +262,51 @@ pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[ Stage5SumcheckEvalPlan { symbol: "stage5.registers_val_evaluation.eval.RdWa", source: "stage5.sumcheck", name: "stage5.registers_val_evaluation.eval.RdWa", index: 1, oracle: "RdWa" }, ]; -pub const STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES: &[Stage5InstructionReadRafPointValuePlan] = &[ - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_0", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 0 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_1", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 1 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_2", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 2 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_3", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 3 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_4", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 4 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_5", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 5 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_6", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 6 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_7", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 7 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_8", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 8 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_9", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 9 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_10", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 10 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_11", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 11 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_12", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 12 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_13", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 13 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_14", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 14 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_15", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 15 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_16", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 16 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_17", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 17 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_18", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 18 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_19", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 19 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_20", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 20 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_21", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 21 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_22", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 22 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_23", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 23 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_24", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 24 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_25", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 25 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_26", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 26 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_27", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 27 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_28", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 28 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_29", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 29 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_30", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 30 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_31", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 31 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_32", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 32 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_33", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 33 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_34", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 34 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_35", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 35 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_36", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 36 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_37", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 37 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_38", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 38 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_39", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 39 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LookupTable_40", kind: Stage5InstructionReadRafPointValueKind::LookupTable { index: 40 } }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.LeftLookupOperand", kind: Stage5InstructionReadRafPointValueKind::LeftOperand }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.RightLookupOperand", kind: Stage5InstructionReadRafPointValueKind::RightOperand }, - Stage5InstructionReadRafPointValuePlan { symbol: "stage5.instruction_read_raf.point_value.Identity", kind: Stage5InstructionReadRafPointValueKind::Identity }, +pub const STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS: &[Stage5InstructionReadRafLocalScalarPlan] = &[ + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_0", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 0 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_1", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 1 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_2", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 2 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_3", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 3 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_4", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 4 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_5", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 5 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_6", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 6 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_7", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 7 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_8", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 8 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_9", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 9 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_10", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 10 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_11", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 11 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_12", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 12 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_13", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 13 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_14", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 14 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_15", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 15 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_16", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 16 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_17", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 17 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_18", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 18 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_19", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 19 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_20", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 20 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_21", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 21 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_22", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 22 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_23", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 23 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_24", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 24 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_25", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 25 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_26", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 26 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_27", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 27 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_28", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 28 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_29", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 29 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_30", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 30 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_31", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 31 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_32", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 32 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_33", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 33 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_34", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 34 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_35", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 35 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_36", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 36 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_37", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 37 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_38", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 38 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_39", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 39 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_40", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 40 } }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LeftLookupOperand", kind: Stage5InstructionReadRafLocalScalarKind::LeftOperand }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.RightLookupOperand", kind: Stage5InstructionReadRafLocalScalarKind::RightOperand }, + Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.Identity", kind: Stage5InstructionReadRafLocalScalarKind::Identity }, ]; pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan { @@ -316,7 +316,7 @@ pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage instruction_ra_evals: &STAGE5_INDEXED_EVAL_FAMILIES[1], raf_flag_eval: "stage5.instruction_read_raf.eval.InstructionRafFlag", gamma: "stage5.instruction_read_raf.gamma", - point_values: STAGE5_INSTRUCTION_READ_RAF_POINT_VALUES, + local_scalars: STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS, log_k: 128, }; @@ -416,7 +416,7 @@ pub const STAGE5_INDEXED_EVAL_FAMILIES: &[bolt_verifier_runtime::NamedEvalFamily bolt_verifier_runtime::NamedEvalFamilyPlan { symbol: "stage5.instruction_read_raf.eval.InstructionRa", evals: STAGE5_INDEXED_EVAL_FAMILY_1_NAMES }, ]; -pub const STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.point_value.LookupTable_0", "stage5.instruction_read_raf.point_value.LookupTable_1", "stage5.instruction_read_raf.point_value.LookupTable_2", "stage5.instruction_read_raf.point_value.LookupTable_3", "stage5.instruction_read_raf.point_value.LookupTable_4", "stage5.instruction_read_raf.point_value.LookupTable_5", "stage5.instruction_read_raf.point_value.LookupTable_6", "stage5.instruction_read_raf.point_value.LookupTable_7", "stage5.instruction_read_raf.point_value.LookupTable_8", "stage5.instruction_read_raf.point_value.LookupTable_9", "stage5.instruction_read_raf.point_value.LookupTable_10", "stage5.instruction_read_raf.point_value.LookupTable_11", "stage5.instruction_read_raf.point_value.LookupTable_12", "stage5.instruction_read_raf.point_value.LookupTable_13", "stage5.instruction_read_raf.point_value.LookupTable_14", "stage5.instruction_read_raf.point_value.LookupTable_15", "stage5.instruction_read_raf.point_value.LookupTable_16", "stage5.instruction_read_raf.point_value.LookupTable_17", "stage5.instruction_read_raf.point_value.LookupTable_18", "stage5.instruction_read_raf.point_value.LookupTable_19", "stage5.instruction_read_raf.point_value.LookupTable_20", "stage5.instruction_read_raf.point_value.LookupTable_21", "stage5.instruction_read_raf.point_value.LookupTable_22", "stage5.instruction_read_raf.point_value.LookupTable_23", "stage5.instruction_read_raf.point_value.LookupTable_24", "stage5.instruction_read_raf.point_value.LookupTable_25", "stage5.instruction_read_raf.point_value.LookupTable_26", "stage5.instruction_read_raf.point_value.LookupTable_27", "stage5.instruction_read_raf.point_value.LookupTable_28", "stage5.instruction_read_raf.point_value.LookupTable_29", "stage5.instruction_read_raf.point_value.LookupTable_30", "stage5.instruction_read_raf.point_value.LookupTable_31", "stage5.instruction_read_raf.point_value.LookupTable_32", "stage5.instruction_read_raf.point_value.LookupTable_33", "stage5.instruction_read_raf.point_value.LookupTable_34", "stage5.instruction_read_raf.point_value.LookupTable_35", "stage5.instruction_read_raf.point_value.LookupTable_36", "stage5.instruction_read_raf.point_value.LookupTable_37", "stage5.instruction_read_raf.point_value.LookupTable_38", "stage5.instruction_read_raf.point_value.LookupTable_39", "stage5.instruction_read_raf.point_value.LookupTable_40", "stage5.instruction_read_raf.point_value.LeftLookupOperand", "stage5.instruction_read_raf.point_value.RightLookupOperand", "stage5.instruction_read_raf.point_value.Identity"]; +pub const STAGE5_RELATION_OUTPUT_2_LOCAL_SCALARS: &[&str] = &["stage5.instruction_read_raf.local_scalar.LookupTable_0", "stage5.instruction_read_raf.local_scalar.LookupTable_1", "stage5.instruction_read_raf.local_scalar.LookupTable_2", "stage5.instruction_read_raf.local_scalar.LookupTable_3", "stage5.instruction_read_raf.local_scalar.LookupTable_4", "stage5.instruction_read_raf.local_scalar.LookupTable_5", "stage5.instruction_read_raf.local_scalar.LookupTable_6", "stage5.instruction_read_raf.local_scalar.LookupTable_7", "stage5.instruction_read_raf.local_scalar.LookupTable_8", "stage5.instruction_read_raf.local_scalar.LookupTable_9", "stage5.instruction_read_raf.local_scalar.LookupTable_10", "stage5.instruction_read_raf.local_scalar.LookupTable_11", "stage5.instruction_read_raf.local_scalar.LookupTable_12", "stage5.instruction_read_raf.local_scalar.LookupTable_13", "stage5.instruction_read_raf.local_scalar.LookupTable_14", "stage5.instruction_read_raf.local_scalar.LookupTable_15", "stage5.instruction_read_raf.local_scalar.LookupTable_16", "stage5.instruction_read_raf.local_scalar.LookupTable_17", "stage5.instruction_read_raf.local_scalar.LookupTable_18", "stage5.instruction_read_raf.local_scalar.LookupTable_19", "stage5.instruction_read_raf.local_scalar.LookupTable_20", "stage5.instruction_read_raf.local_scalar.LookupTable_21", "stage5.instruction_read_raf.local_scalar.LookupTable_22", "stage5.instruction_read_raf.local_scalar.LookupTable_23", "stage5.instruction_read_raf.local_scalar.LookupTable_24", "stage5.instruction_read_raf.local_scalar.LookupTable_25", "stage5.instruction_read_raf.local_scalar.LookupTable_26", "stage5.instruction_read_raf.local_scalar.LookupTable_27", "stage5.instruction_read_raf.local_scalar.LookupTable_28", "stage5.instruction_read_raf.local_scalar.LookupTable_29", "stage5.instruction_read_raf.local_scalar.LookupTable_30", "stage5.instruction_read_raf.local_scalar.LookupTable_31", "stage5.instruction_read_raf.local_scalar.LookupTable_32", "stage5.instruction_read_raf.local_scalar.LookupTable_33", "stage5.instruction_read_raf.local_scalar.LookupTable_34", "stage5.instruction_read_raf.local_scalar.LookupTable_35", "stage5.instruction_read_raf.local_scalar.LookupTable_36", "stage5.instruction_read_raf.local_scalar.LookupTable_37", "stage5.instruction_read_raf.local_scalar.LookupTable_38", "stage5.instruction_read_raf.local_scalar.LookupTable_39", "stage5.instruction_read_raf.local_scalar.LookupTable_40", "stage5.instruction_read_raf.local_scalar.LeftLookupOperand", "stage5.instruction_read_raf.local_scalar.RightLookupOperand", "stage5.instruction_read_raf.local_scalar.Identity"]; pub const STAGE5_RELATION_OUTPUTS: &[Stage5RelationOutputPlan] = &[ Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RamRaClaimReduction, local_scalars: &[], expected_output: "stage5.ram_ra_claim_reduction.output.claim_expr" }, Stage5RelationOutputPlan { relation: Stage5RelationKind::Stage5RegistersValEvaluation, local_scalars: &[], expected_output: "stage5.registers_val_evaluation.output.claim_expr" }, @@ -706,7 +706,7 @@ fn stage5_relation_output_inputs<'a>( Ok(bolt_verifier_runtime::RelationOutputInputs { scalars: bolt_verifier_runtime::select_named_scalars( relation_output.local_scalars, - evaluate_stage5_instruction_read_raf_point_scalars( + evaluate_stage5_instruction_read_raf_local_scalars( &program.instruction_read_raf_plan, local_point, )?, From bcde1a29bd160ea4bfc8d6d6dda9fc03eef95bb4 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 08:19:59 -0600 Subject: [PATCH 145/171] refactor(verifier): reuse jolt local scalar rows --- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../jolt/stage5_instruction_read_raf_plan.rs | 57 +++++------- .../jolt/verifier_jolt_relations.rs.template | 43 ++++----- crates/bolt/tests/commitment_ir.rs | 2 +- .../src/stages/jolt_relations.rs | 44 ++++----- crates/jolt-verifier/src/stages/stage5.rs | 92 +++++++++---------- 6 files changed, 116 insertions(+), 124 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index e267a5f259..6620ae7ef5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -936,7 +936,7 @@ impl Stage5CpuProgram { fn emit_verifier_imports() -> &'static str { "use bolt_verifier_runtime::find_plan;\n\ - use super::jolt_relations::{evaluate_stage5_instruction_read_raf_local_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafLocalScalarKind, Stage5InstructionReadRafLocalScalarPlan};\n\ + use super::jolt_relations::{evaluate_stage5_instruction_read_raf_local_scalars, normalize_instruction_read_raf_point, JoltLocalScalarMleKind, JoltLocalScalarPlan, Stage5InstructionReadRafPlan};\n\ use jolt_field::{Field, Fr};\n\ use jolt_sumcheck::SumcheckError;\n\ use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript};" diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 96eaa52b5a..35ef24f379 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -22,7 +22,7 @@ pub(crate) struct Stage5InstructionReadRafEmitPlan { pub(crate) instruction_ra_evals_ref: String, pub(crate) raf_flag_eval: String, pub(crate) gamma: String, - pub(crate) local_scalars: Vec, + pub(crate) local_scalars: Vec, pub(crate) log_k: usize, } @@ -219,9 +219,9 @@ impl Stage5InstructionReadRafEmitPlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct Stage5InstructionReadRafLocalScalarEmitPlan { +pub(crate) struct JoltLocalScalarEmitPlan { pub(crate) symbol: String, - pub(crate) kind: Stage5InstructionReadRafLocalScalarKind, + pub(crate) kind: JoltLocalScalarMleKind, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -238,42 +238,39 @@ pub(crate) struct Stage5InstructionReadRafOutputFieldExprPlan { pub(crate) operands: Vec, } -impl Stage5InstructionReadRafLocalScalarEmitPlan { +impl JoltLocalScalarEmitPlan { pub(crate) fn is_lookup_table(&self) -> bool { - matches!( - self.kind, - Stage5InstructionReadRafLocalScalarKind::LookupTable { .. } - ) + matches!(self.kind, JoltLocalScalarMleKind::LookupTable { .. }) } } #[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) enum Stage5InstructionReadRafLocalScalarKind { +pub(crate) enum JoltLocalScalarMleKind { LookupTable { index: usize }, LeftOperand, RightOperand, Identity, } -fn local_scalar_plans(table_count: usize) -> Vec { +fn local_scalar_plans(table_count: usize) -> Vec { let mut values = (0..table_count) - .map(|index| Stage5InstructionReadRafLocalScalarEmitPlan { + .map(|index| JoltLocalScalarEmitPlan { symbol: format!("stage5.instruction_read_raf.local_scalar.LookupTable_{index}"), - kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index }, + kind: JoltLocalScalarMleKind::LookupTable { index }, }) .collect::>(); values.extend([ - Stage5InstructionReadRafLocalScalarEmitPlan { + JoltLocalScalarEmitPlan { symbol: "stage5.instruction_read_raf.local_scalar.LeftLookupOperand".to_owned(), - kind: Stage5InstructionReadRafLocalScalarKind::LeftOperand, + kind: JoltLocalScalarMleKind::LeftOperand, }, - Stage5InstructionReadRafLocalScalarEmitPlan { + JoltLocalScalarEmitPlan { symbol: "stage5.instruction_read_raf.local_scalar.RightLookupOperand".to_owned(), - kind: Stage5InstructionReadRafLocalScalarKind::RightOperand, + kind: JoltLocalScalarMleKind::RightOperand, }, - Stage5InstructionReadRafLocalScalarEmitPlan { + JoltLocalScalarEmitPlan { symbol: "stage5.instruction_read_raf.local_scalar.Identity".to_owned(), - kind: Stage5InstructionReadRafLocalScalarKind::Identity, + kind: JoltLocalScalarMleKind::Identity, }, ]); values @@ -291,12 +288,12 @@ fn output_field_expr( } } -fn emit_local_scalar_constants(values: &[Stage5InstructionReadRafLocalScalarEmitPlan]) -> String { +fn emit_local_scalar_constants(values: &[JoltLocalScalarEmitPlan]) -> String { let values = values .iter() .map(|value| { format!( - " Stage5InstructionReadRafLocalScalarPlan {{ symbol: {}, kind: {} }},", + " JoltLocalScalarPlan {{ symbol: {}, kind: {} }},", rust_str(&value.symbol), local_scalar_kind_expr(&value.kind), ) @@ -304,24 +301,18 @@ fn emit_local_scalar_constants(values: &[Stage5InstructionReadRafLocalScalarEmit .collect::>() .join("\n"); format!( - "pub const STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS: &[Stage5InstructionReadRafLocalScalarPlan] = &[\n{values}\n];\n\n" + "pub const STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS: &[JoltLocalScalarPlan] = &[\n{values}\n];\n\n" ) } -fn local_scalar_kind_expr(kind: &Stage5InstructionReadRafLocalScalarKind) -> String { +fn local_scalar_kind_expr(kind: &JoltLocalScalarMleKind) -> String { match kind { - Stage5InstructionReadRafLocalScalarKind::LookupTable { index } => { - format!("Stage5InstructionReadRafLocalScalarKind::LookupTable {{ index: {index} }}") - } - Stage5InstructionReadRafLocalScalarKind::LeftOperand => { - "Stage5InstructionReadRafLocalScalarKind::LeftOperand".to_owned() - } - Stage5InstructionReadRafLocalScalarKind::RightOperand => { - "Stage5InstructionReadRafLocalScalarKind::RightOperand".to_owned() - } - Stage5InstructionReadRafLocalScalarKind::Identity => { - "Stage5InstructionReadRafLocalScalarKind::Identity".to_owned() + JoltLocalScalarMleKind::LookupTable { index } => { + format!("JoltLocalScalarMleKind::LookupTable {{ index: {index} }}") } + JoltLocalScalarMleKind::LeftOperand => "JoltLocalScalarMleKind::LeftOperand".to_owned(), + JoltLocalScalarMleKind::RightOperand => "JoltLocalScalarMleKind::RightOperand".to_owned(), + JoltLocalScalarMleKind::Identity => "JoltLocalScalarMleKind::Identity".to_owned(), } } diff --git a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template index 854bd9dd1b..4615299bfe 100644 --- a/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template +++ b/crates/bolt/src/protocols/jolt/verifier_jolt_relations.rs.template @@ -94,18 +94,18 @@ pub struct Stage5InstructionReadRafPlan { pub instruction_ra_evals: &'static NamedEvalFamilyPlan, pub raf_flag_eval: &'static str, pub gamma: &'static str, - pub local_scalars: &'static [Stage5InstructionReadRafLocalScalarPlan], + pub local_scalars: &'static [JoltLocalScalarPlan], pub log_k: usize, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage5InstructionReadRafLocalScalarPlan { +pub struct JoltLocalScalarPlan { pub symbol: &'static str, - pub kind: Stage5InstructionReadRafLocalScalarKind, + pub kind: JoltLocalScalarMleKind, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Stage5InstructionReadRafLocalScalarKind { +pub enum JoltLocalScalarMleKind { LookupTable { index: usize }, LeftOperand, RightOperand, @@ -229,9 +229,16 @@ pub fn evaluate_stage5_instruction_read_raf_local_scalars( local_point: &[Fr], ) -> Result>, RuntimePlanError> { let (r_address_prime, _) = instruction_read_raf_point_parts(plan, local_point)?; - let mut scalars = Vec::with_capacity(plan.local_scalars.len()); - for value in plan.local_scalars { - let scalar = evaluate_stage5_instruction_read_raf_local_scalar(value.kind, r_address_prime)?; + evaluate_jolt_local_scalars(plan.local_scalars, r_address_prime) +} + +pub fn evaluate_jolt_local_scalars( + plans: &[JoltLocalScalarPlan], + point: &[Fr], +) -> Result>, RuntimePlanError> { + let mut scalars = Vec::with_capacity(plans.len()); + for value in plans { + let scalar = evaluate_jolt_local_scalar(value.kind, point)?; scalars.push(NamedScalar { symbol: value.symbol, value: scalar, @@ -240,13 +247,13 @@ pub fn evaluate_stage5_instruction_read_raf_local_scalars( Ok(scalars) } -fn evaluate_stage5_instruction_read_raf_local_scalar( - kind: Stage5InstructionReadRafLocalScalarKind, - r_address_prime: &[Fr], +fn evaluate_jolt_local_scalar( + kind: JoltLocalScalarMleKind, + point: &[Fr], ) -> Result { const XLEN: usize = 64; Ok(match kind { - Stage5InstructionReadRafLocalScalarKind::LookupTable { index } => { + JoltLocalScalarMleKind::LookupTable { index } => { let tables = LookupTableKind::::all(); let table = tables .get(index) @@ -255,17 +262,11 @@ fn evaluate_stage5_instruction_read_raf_local_scalar( expected: tables.len(), actual: index + 1, })?; - table.evaluate_mle::(r_address_prime) - } - Stage5InstructionReadRafLocalScalarKind::LeftOperand => { - operand_polynomial_eval(r_address_prime, true)? - } - Stage5InstructionReadRafLocalScalarKind::RightOperand => { - operand_polynomial_eval(r_address_prime, false)? - } - Stage5InstructionReadRafLocalScalarKind::Identity => { - IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime) + table.evaluate_mle::(point) } + JoltLocalScalarMleKind::LeftOperand => operand_polynomial_eval(point, true)?, + JoltLocalScalarMleKind::RightOperand => operand_polynomial_eval(point, false)?, + JoltLocalScalarMleKind::Identity => IdentityPolynomial::new(point.len()).evaluate(point), }) } diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index f5867a0e02..c9217f406a 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1473,7 +1473,7 @@ fn stage5_rust_targets_extract_and_compile() { .contains("Stage5RelationKind::Stage5InstructionReadRaf")); assert!(verifier_source .source - .contains("Stage5InstructionReadRafLocalScalarKind::LookupTable")); + .contains("JoltLocalScalarMleKind::LookupTable")); assert!(!verifier_source .source .contains("expected_ram_ra_claim_reduction")); diff --git a/crates/jolt-verifier/src/stages/jolt_relations.rs b/crates/jolt-verifier/src/stages/jolt_relations.rs index 5210e92d38..4615299bfe 100644 --- a/crates/jolt-verifier/src/stages/jolt_relations.rs +++ b/crates/jolt-verifier/src/stages/jolt_relations.rs @@ -94,18 +94,18 @@ pub struct Stage5InstructionReadRafPlan { pub instruction_ra_evals: &'static NamedEvalFamilyPlan, pub raf_flag_eval: &'static str, pub gamma: &'static str, - pub local_scalars: &'static [Stage5InstructionReadRafLocalScalarPlan], + pub local_scalars: &'static [JoltLocalScalarPlan], pub log_k: usize, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub struct Stage5InstructionReadRafLocalScalarPlan { +pub struct JoltLocalScalarPlan { pub symbol: &'static str, - pub kind: Stage5InstructionReadRafLocalScalarKind, + pub kind: JoltLocalScalarMleKind, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum Stage5InstructionReadRafLocalScalarKind { +pub enum JoltLocalScalarMleKind { LookupTable { index: usize }, LeftOperand, RightOperand, @@ -229,10 +229,16 @@ pub fn evaluate_stage5_instruction_read_raf_local_scalars( local_point: &[Fr], ) -> Result>, RuntimePlanError> { let (r_address_prime, _) = instruction_read_raf_point_parts(plan, local_point)?; - let mut scalars = Vec::with_capacity(plan.local_scalars.len()); - for value in plan.local_scalars { - let scalar = - evaluate_stage5_instruction_read_raf_local_scalar(value.kind, r_address_prime)?; + evaluate_jolt_local_scalars(plan.local_scalars, r_address_prime) +} + +pub fn evaluate_jolt_local_scalars( + plans: &[JoltLocalScalarPlan], + point: &[Fr], +) -> Result>, RuntimePlanError> { + let mut scalars = Vec::with_capacity(plans.len()); + for value in plans { + let scalar = evaluate_jolt_local_scalar(value.kind, point)?; scalars.push(NamedScalar { symbol: value.symbol, value: scalar, @@ -241,13 +247,13 @@ pub fn evaluate_stage5_instruction_read_raf_local_scalars( Ok(scalars) } -fn evaluate_stage5_instruction_read_raf_local_scalar( - kind: Stage5InstructionReadRafLocalScalarKind, - r_address_prime: &[Fr], +fn evaluate_jolt_local_scalar( + kind: JoltLocalScalarMleKind, + point: &[Fr], ) -> Result { const XLEN: usize = 64; Ok(match kind { - Stage5InstructionReadRafLocalScalarKind::LookupTable { index } => { + JoltLocalScalarMleKind::LookupTable { index } => { let tables = LookupTableKind::::all(); let table = tables .get(index) @@ -256,17 +262,11 @@ fn evaluate_stage5_instruction_read_raf_local_scalar( expected: tables.len(), actual: index + 1, })?; - table.evaluate_mle::(r_address_prime) - } - Stage5InstructionReadRafLocalScalarKind::LeftOperand => { - operand_polynomial_eval(r_address_prime, true)? - } - Stage5InstructionReadRafLocalScalarKind::RightOperand => { - operand_polynomial_eval(r_address_prime, false)? - } - Stage5InstructionReadRafLocalScalarKind::Identity => { - IdentityPolynomial::new(r_address_prime.len()).evaluate(r_address_prime) + table.evaluate_mle::(point) } + JoltLocalScalarMleKind::LeftOperand => operand_polynomial_eval(point, true)?, + JoltLocalScalarMleKind::RightOperand => operand_polynomial_eval(point, false)?, + JoltLocalScalarMleKind::Identity => IdentityPolynomial::new(point.len()).evaluate(point), }) } diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index e2f3ff752f..0cf263f4f2 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -1,7 +1,7 @@ #![allow(dead_code)] use bolt_verifier_runtime::find_plan; -use super::jolt_relations::{evaluate_stage5_instruction_read_raf_local_scalars, normalize_instruction_read_raf_point, Stage5InstructionReadRafPlan, Stage5InstructionReadRafLocalScalarKind, Stage5InstructionReadRafLocalScalarPlan}; +use super::jolt_relations::{evaluate_stage5_instruction_read_raf_local_scalars, normalize_instruction_read_raf_point, JoltLocalScalarMleKind, JoltLocalScalarPlan, Stage5InstructionReadRafPlan}; use jolt_field::{Field, Fr}; use jolt_sumcheck::SumcheckError; use jolt_transcript::{Blake2bTranscript, LabelWithCount, Transcript}; @@ -262,51 +262,51 @@ pub const STAGE5_SUMCHECK_EVALS: &[Stage5SumcheckEvalPlan] = &[ Stage5SumcheckEvalPlan { symbol: "stage5.registers_val_evaluation.eval.RdWa", source: "stage5.sumcheck", name: "stage5.registers_val_evaluation.eval.RdWa", index: 1, oracle: "RdWa" }, ]; -pub const STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS: &[Stage5InstructionReadRafLocalScalarPlan] = &[ - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_0", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 0 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_1", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 1 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_2", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 2 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_3", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 3 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_4", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 4 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_5", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 5 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_6", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 6 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_7", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 7 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_8", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 8 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_9", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 9 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_10", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 10 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_11", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 11 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_12", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 12 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_13", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 13 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_14", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 14 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_15", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 15 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_16", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 16 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_17", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 17 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_18", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 18 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_19", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 19 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_20", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 20 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_21", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 21 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_22", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 22 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_23", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 23 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_24", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 24 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_25", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 25 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_26", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 26 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_27", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 27 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_28", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 28 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_29", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 29 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_30", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 30 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_31", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 31 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_32", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 32 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_33", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 33 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_34", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 34 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_35", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 35 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_36", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 36 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_37", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 37 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_38", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 38 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_39", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 39 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_40", kind: Stage5InstructionReadRafLocalScalarKind::LookupTable { index: 40 } }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LeftLookupOperand", kind: Stage5InstructionReadRafLocalScalarKind::LeftOperand }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.RightLookupOperand", kind: Stage5InstructionReadRafLocalScalarKind::RightOperand }, - Stage5InstructionReadRafLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.Identity", kind: Stage5InstructionReadRafLocalScalarKind::Identity }, +pub const STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS: &[JoltLocalScalarPlan] = &[ + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_0", kind: JoltLocalScalarMleKind::LookupTable { index: 0 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_1", kind: JoltLocalScalarMleKind::LookupTable { index: 1 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_2", kind: JoltLocalScalarMleKind::LookupTable { index: 2 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_3", kind: JoltLocalScalarMleKind::LookupTable { index: 3 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_4", kind: JoltLocalScalarMleKind::LookupTable { index: 4 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_5", kind: JoltLocalScalarMleKind::LookupTable { index: 5 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_6", kind: JoltLocalScalarMleKind::LookupTable { index: 6 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_7", kind: JoltLocalScalarMleKind::LookupTable { index: 7 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_8", kind: JoltLocalScalarMleKind::LookupTable { index: 8 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_9", kind: JoltLocalScalarMleKind::LookupTable { index: 9 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_10", kind: JoltLocalScalarMleKind::LookupTable { index: 10 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_11", kind: JoltLocalScalarMleKind::LookupTable { index: 11 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_12", kind: JoltLocalScalarMleKind::LookupTable { index: 12 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_13", kind: JoltLocalScalarMleKind::LookupTable { index: 13 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_14", kind: JoltLocalScalarMleKind::LookupTable { index: 14 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_15", kind: JoltLocalScalarMleKind::LookupTable { index: 15 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_16", kind: JoltLocalScalarMleKind::LookupTable { index: 16 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_17", kind: JoltLocalScalarMleKind::LookupTable { index: 17 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_18", kind: JoltLocalScalarMleKind::LookupTable { index: 18 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_19", kind: JoltLocalScalarMleKind::LookupTable { index: 19 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_20", kind: JoltLocalScalarMleKind::LookupTable { index: 20 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_21", kind: JoltLocalScalarMleKind::LookupTable { index: 21 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_22", kind: JoltLocalScalarMleKind::LookupTable { index: 22 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_23", kind: JoltLocalScalarMleKind::LookupTable { index: 23 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_24", kind: JoltLocalScalarMleKind::LookupTable { index: 24 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_25", kind: JoltLocalScalarMleKind::LookupTable { index: 25 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_26", kind: JoltLocalScalarMleKind::LookupTable { index: 26 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_27", kind: JoltLocalScalarMleKind::LookupTable { index: 27 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_28", kind: JoltLocalScalarMleKind::LookupTable { index: 28 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_29", kind: JoltLocalScalarMleKind::LookupTable { index: 29 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_30", kind: JoltLocalScalarMleKind::LookupTable { index: 30 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_31", kind: JoltLocalScalarMleKind::LookupTable { index: 31 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_32", kind: JoltLocalScalarMleKind::LookupTable { index: 32 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_33", kind: JoltLocalScalarMleKind::LookupTable { index: 33 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_34", kind: JoltLocalScalarMleKind::LookupTable { index: 34 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_35", kind: JoltLocalScalarMleKind::LookupTable { index: 35 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_36", kind: JoltLocalScalarMleKind::LookupTable { index: 36 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_37", kind: JoltLocalScalarMleKind::LookupTable { index: 37 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_38", kind: JoltLocalScalarMleKind::LookupTable { index: 38 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_39", kind: JoltLocalScalarMleKind::LookupTable { index: 39 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LookupTable_40", kind: JoltLocalScalarMleKind::LookupTable { index: 40 } }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.LeftLookupOperand", kind: JoltLocalScalarMleKind::LeftOperand }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.RightLookupOperand", kind: JoltLocalScalarMleKind::RightOperand }, + JoltLocalScalarPlan { symbol: "stage5.instruction_read_raf.local_scalar.Identity", kind: JoltLocalScalarMleKind::Identity }, ]; pub const STAGE5_INSTRUCTION_READ_RAF_PLAN: Stage5InstructionReadRafPlan = Stage5InstructionReadRafPlan { From b5c24b1e18026c8412102b2dc57376f3d5f209aa Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 08:25:13 -0600 Subject: [PATCH 146/171] refactor(verifier): move local scalar rows --- crates/bolt/src/protocols/jolt/mod.rs | 1 + .../jolt/stage5_instruction_read_raf_plan.rs | 58 +++---------------- .../protocols/jolt/verifier_local_scalars.rs | 52 +++++++++++++++++ 3 files changed, 62 insertions(+), 49 deletions(-) create mode 100644 crates/bolt/src/protocols/jolt/verifier_local_scalars.rs diff --git a/crates/bolt/src/protocols/jolt/mod.rs b/crates/bolt/src/protocols/jolt/mod.rs index da4161aa4a..2fe67f7774 100644 --- a/crates/bolt/src/protocols/jolt/mod.rs +++ b/crates/bolt/src/protocols/jolt/mod.rs @@ -9,6 +9,7 @@ pub(crate) mod stage5_instruction_read_raf_plan; pub(crate) mod stage6_bytecode_read_raf_plan; pub mod validate; pub(crate) mod verifier_eval_families; +pub(crate) mod verifier_local_scalars; pub(crate) mod verifier_opening_rows; pub(crate) mod verifier_plan; pub(crate) mod verifier_point_rows; diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 35ef24f379..ca15f96df7 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -1,5 +1,8 @@ use crate::emit::rust::{push_format, EmitError}; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; +use crate::protocols::jolt::verifier_local_scalars::{ + emit_jolt_local_scalar_constants, JoltLocalScalarEmitPlan, JoltLocalScalarMleKind, +}; use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputPlan, StructuredPolynomialEvalPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, @@ -11,6 +14,8 @@ pub(crate) const STAGE5_TABLE_FLAG_EVAL_FAMILY: &str = pub(crate) const STAGE5_INSTRUCTION_RA_EVAL_FAMILY: &str = "stage5.instruction_read_raf.eval.InstructionRa"; const STAGE5_INDEXED_EVAL_FAMILIES_CONST: &str = "STAGE5_INDEXED_EVAL_FAMILIES"; +const STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS_CONST: &str = + "STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS"; #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Stage5InstructionReadRafEmitPlan { @@ -53,7 +58,10 @@ impl Stage5InstructionReadRafEmitPlan { pub(crate) fn emit_runtime_constants(&self) -> String { let mut source = String::new(); - source.push_str(&emit_local_scalar_constants(&self.local_scalars)); + source.push_str(&emit_jolt_local_scalar_constants( + STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS_CONST, + &self.local_scalars, + )); push_format( &mut source, format_args!( @@ -218,12 +226,6 @@ impl Stage5InstructionReadRafEmitPlan { } } -#[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct JoltLocalScalarEmitPlan { - pub(crate) symbol: String, - pub(crate) kind: JoltLocalScalarMleKind, -} - #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct Stage5InstructionReadRafOutputPlan { pub(crate) relation_output_values: Vec, @@ -238,20 +240,6 @@ pub(crate) struct Stage5InstructionReadRafOutputFieldExprPlan { pub(crate) operands: Vec, } -impl JoltLocalScalarEmitPlan { - pub(crate) fn is_lookup_table(&self) -> bool { - matches!(self.kind, JoltLocalScalarMleKind::LookupTable { .. }) - } -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) enum JoltLocalScalarMleKind { - LookupTable { index: usize }, - LeftOperand, - RightOperand, - Identity, -} - fn local_scalar_plans(table_count: usize) -> Vec { let mut values = (0..table_count) .map(|index| JoltLocalScalarEmitPlan { @@ -288,34 +276,6 @@ fn output_field_expr( } } -fn emit_local_scalar_constants(values: &[JoltLocalScalarEmitPlan]) -> String { - let values = values - .iter() - .map(|value| { - format!( - " JoltLocalScalarPlan {{ symbol: {}, kind: {} }},", - rust_str(&value.symbol), - local_scalar_kind_expr(&value.kind), - ) - }) - .collect::>() - .join("\n"); - format!( - "pub const STAGE5_INSTRUCTION_READ_RAF_LOCAL_SCALARS: &[JoltLocalScalarPlan] = &[\n{values}\n];\n\n" - ) -} - -fn local_scalar_kind_expr(kind: &JoltLocalScalarMleKind) -> String { - match kind { - JoltLocalScalarMleKind::LookupTable { index } => { - format!("JoltLocalScalarMleKind::LookupTable {{ index: {index} }}") - } - JoltLocalScalarMleKind::LeftOperand => "JoltLocalScalarMleKind::LeftOperand".to_owned(), - JoltLocalScalarMleKind::RightOperand => "JoltLocalScalarMleKind::RightOperand".to_owned(), - JoltLocalScalarMleKind::Identity => "JoltLocalScalarMleKind::Identity".to_owned(), - } -} - fn rust_str(value: &str) -> String { format!("{value:?}") } diff --git a/crates/bolt/src/protocols/jolt/verifier_local_scalars.rs b/crates/bolt/src/protocols/jolt/verifier_local_scalars.rs new file mode 100644 index 0000000000..b8359b76b5 --- /dev/null +++ b/crates/bolt/src/protocols/jolt/verifier_local_scalars.rs @@ -0,0 +1,52 @@ +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct JoltLocalScalarEmitPlan { + pub(crate) symbol: String, + pub(crate) kind: JoltLocalScalarMleKind, +} + +impl JoltLocalScalarEmitPlan { + pub(crate) fn is_lookup_table(&self) -> bool { + matches!(self.kind, JoltLocalScalarMleKind::LookupTable { .. }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum JoltLocalScalarMleKind { + LookupTable { index: usize }, + LeftOperand, + RightOperand, + Identity, +} + +pub(crate) fn emit_jolt_local_scalar_constants( + const_name: &str, + values: &[JoltLocalScalarEmitPlan], +) -> String { + let values = values + .iter() + .map(|value| { + format!( + " JoltLocalScalarPlan {{ symbol: {}, kind: {} }},", + rust_str(&value.symbol), + local_scalar_kind_expr(&value.kind), + ) + }) + .collect::>() + .join("\n"); + format!("pub const {const_name}: &[JoltLocalScalarPlan] = &[\n{values}\n];\n\n") +} + +fn local_scalar_kind_expr(kind: &JoltLocalScalarMleKind) -> String { + match kind { + JoltLocalScalarMleKind::LookupTable { index } => { + format!("JoltLocalScalarMleKind::LookupTable {{ index: {index} }}") + } + JoltLocalScalarMleKind::LeftOperand => "JoltLocalScalarMleKind::LeftOperand".to_owned(), + JoltLocalScalarMleKind::RightOperand => "JoltLocalScalarMleKind::RightOperand".to_owned(), + JoltLocalScalarMleKind::Identity => "JoltLocalScalarMleKind::Identity".to_owned(), + } +} + +fn rust_str(value: &str) -> String { + format!("{value:?}") +} From dbc4e1aa2a6fc8d4c6c95d7e621b5a9ba19e5ec8 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 08:37:04 -0600 Subject: [PATCH 147/171] refactor(verifier): route scalar value rows --- .../bolt/src/protocols/jolt/verifier_plan.rs | 246 ++++++++++++++---- .../src/protocols/jolt/verifier_values.rs | 62 +++++ 2 files changed, 255 insertions(+), 53 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 7bb383c8f6..3d43df5035 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -31,7 +31,8 @@ use crate::protocols::jolt::verifier_value_rows::{ }; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorSourceKind, VerifierFieldVectorSourceSet, VerifierPointSourceKind, - VerifierPointSourceSet, VerifierScalarSourceKind, VerifierScalarSourceSet, + VerifierPointSourceSet, VerifierScalarSourceSet, VerifierScalarValueKind, + VerifierScalarValuePlan, }; #[derive(Clone, Debug, PartialEq, Eq)] @@ -310,17 +311,22 @@ impl VerifierRelationLocalInputPlan { } } - fn insert_scalar_sources(&self, values: &mut VerifierScalarSourceSet) { + fn extend_scalar_value_plans(&self, values: &mut Vec) { match self { Self::Stage5InstructionReadRaf(plan) => { - values.extend( - plan.local_scalar_symbols(), - VerifierScalarSourceKind::RelationOutputLocal, - ); + values.extend(plan.local_scalar_symbols().map(|symbol| { + VerifierScalarValuePlan::new( + symbol.clone(), + VerifierScalarValueKind::RelationOutputLocal, + ) + })); } Self::Stage6BytecodeReadRaf(_) => { for symbol in Stage6BytecodeReadRafEmitPlan::local_scalar_symbols() { - values.insert(symbol, VerifierScalarSourceKind::RelationOutputLocal); + values.push(VerifierScalarValuePlan::new( + symbol, + VerifierScalarValueKind::RelationOutputLocal, + )); } } } @@ -385,14 +391,14 @@ impl VerifierRelationLocalInputPlans { Ok(()) } - fn insert_scalar_sources(&self, values: &mut VerifierScalarSourceSet) { + fn extend_scalar_value_plans(&self, values: &mut Vec) { for row in &self.rows { - row.insert_scalar_sources(values); + row.extend_scalar_value_plans(values); } } } -#[derive(Clone, Debug, PartialEq, Eq)] +#[derive(Clone, Debug, Default, PartialEq, Eq)] pub(crate) struct VerifierStagePlan { pub(crate) steps: Vec, pub(crate) transcript_squeezes: Vec, @@ -420,16 +426,14 @@ pub(crate) struct VerifierStagePlan { } impl VerifierStagePlan { - pub(crate) fn scalar_value_sources(&self) -> VerifierScalarSourceSet { - let mut values = VerifierScalarSourceSet::default(); - values.extend( - self.opening_inputs.iter().map(|input| &input.symbol), - VerifierScalarSourceKind::OpeningInput, - ); - values.extend( - self.field_constants.iter().map(|constant| &constant.symbol), - VerifierScalarSourceKind::FieldConstant, - ); + pub(crate) fn scalar_value_plans(&self) -> Vec { + let mut values = Vec::new(); + values.extend(self.opening_inputs.iter().map(|input| { + VerifierScalarValuePlan::new(&input.symbol, VerifierScalarValueKind::OpeningInput) + })); + values.extend(self.field_constants.iter().map(|constant| { + VerifierScalarValuePlan::new(&constant.symbol, VerifierScalarValueKind::FieldConstant) + })); values.extend( self.transcript_squeezes .iter() @@ -439,41 +443,69 @@ impl VerifierStagePlan { TranscriptSqueezeKind::ChallengeScalar | TranscriptSqueezeKind::Scalar ) }) - .map(|squeeze| &squeeze.symbol), - VerifierScalarSourceKind::TranscriptScalar, - ); - values.extend( - self.relation_output_eval_families - .iter() - .map(|family| &family.symbol), - VerifierScalarSourceKind::OutputEvalFamily, - ); - values.extend( - self.relation_output_product_families - .iter() - .map(|family| &family.symbol), - VerifierScalarSourceKind::OutputProductFamily, - ); - values.extend( - self.relation_output_function_families - .iter() - .map(|family| &family.symbol), - VerifierScalarSourceKind::OutputFunctionFamily, - ); - values.extend( - self.field_exprs.iter().map(|expr| &expr.symbol), - VerifierScalarSourceKind::FieldExpr, - ); - values.extend( - self.scalar_exprs.iter().map(|expr| &expr.symbol), - VerifierScalarSourceKind::ScalarExpr, + .map(|squeeze| { + VerifierScalarValuePlan::new( + &squeeze.symbol, + VerifierScalarValueKind::TranscriptScalar, + ) + }), ); + values.extend(self.relation_output_values.iter().map(|value| { + VerifierScalarValuePlan::new( + &value.symbol, + VerifierScalarValueKind::StructuredPolynomialEval, + ) + })); + values.extend(self.relation_output_eval_families.iter().map(|family| { + VerifierScalarValuePlan::new(&family.symbol, VerifierScalarValueKind::OutputEvalFamily) + })); + values.extend(self.relation_output_product_families.iter().map(|family| { + VerifierScalarValuePlan::new( + &family.symbol, + VerifierScalarValueKind::OutputProductFamily, + ) + })); + values.extend(self.relation_output_function_families.iter().map(|family| { + VerifierScalarValuePlan::new( + &family.symbol, + VerifierScalarValueKind::OutputFunctionFamily, + ) + })); + values.extend(self.field_exprs.iter().map(|expr| { + VerifierScalarValuePlan::new(&expr.symbol, VerifierScalarValueKind::FieldExpr) + })); + let structured_eval_symbols = self + .relation_output_values + .iter() + .map(|value| value.symbol.as_str()) + .collect::>(); + values.extend(self.scalar_exprs.iter().filter_map(|expr| { + if matches!(expr.kind, ScalarExprKind::StructuredPolynomial { .. }) { + if structured_eval_symbols.contains(expr.symbol.as_str()) { + return None; + } + return Some(VerifierScalarValuePlan::new( + &expr.symbol, + VerifierScalarValueKind::StructuredPolynomialEval, + )); + } + Some(VerifierScalarValuePlan::new( + &expr.symbol, + VerifierScalarValueKind::ScalarExpr, + )) + })); self.relation_local_inputs - .insert_scalar_sources(&mut values); - values.extend( - self.sumcheck_evals.iter().map(|eval| &eval.symbol), - VerifierScalarSourceKind::SumcheckEval, - ); + .extend_scalar_value_plans(&mut values); + values.extend(self.sumcheck_evals.iter().map(|eval| { + VerifierScalarValuePlan::new(&eval.symbol, VerifierScalarValueKind::SumcheckEval) + })); + values + } + + pub(crate) fn scalar_value_sources(&self) -> VerifierScalarSourceSet { + let mut values = VerifierScalarSourceSet::default(); + let plans = self.scalar_value_plans(); + values.extend_plans(&plans); values } @@ -2134,3 +2166,111 @@ fn rust_str(value: &str) -> String { fn plan_error(error: RustTargetPlanError) -> EmitError { EmitError::new(error.to_string()) } + +#[cfg(test)] +mod tests { + use crate::protocols::jolt::rust_target_plan::ScalarExprKind; + use crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionReadRafEmitPlan; + use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; + use crate::protocols::jolt::verifier_local_scalars::{ + JoltLocalScalarEmitPlan, JoltLocalScalarMleKind, + }; + use crate::protocols::jolt::verifier_relation_outputs::{ + StructuredPolynomialEvalPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, + StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment, + }; + use crate::protocols::jolt::verifier_values::{ + VerifierScalarValueKind, VerifierScalarValuePlan, + }; + + use super::{VerifierScalarExprPlan, VerifierStagePlan}; + + #[test] + fn scalar_value_plans_classify_structured_evals_and_local_scalars() -> Result<(), String> { + let mut plan = VerifierStagePlan::default(); + plan.relation_output_values + .push(structured_polynomial_eval("stage5.output.eq")); + plan.scalar_exprs.push(VerifierScalarExprPlan { + symbol: "stage5.output.eq".to_owned(), + kind: ScalarExprKind::from_cpu_attr( + "poly.structured_eval:eq:full:full:as_is:full:full:as_is", + ) + .map_err(|error| error.to_string())?, + operands: vec!["point.x".to_owned(), "point.y".to_owned()], + }); + plan.scalar_exprs.push(VerifierScalarExprPlan { + symbol: "stage5.output.sum".to_owned(), + kind: ScalarExprKind::FieldVectorSum, + operands: vec!["field.vector".to_owned()], + }); + plan.relation_local_inputs + .add_stage5_instruction_read_raf(stage5_local_input_plan()) + .map_err(|error| error.to_string())?; + + let values = plan.scalar_value_plans(); + + assert_eq!( + values + .iter() + .filter(|value| value.symbol == "stage5.output.eq") + .count(), + 1 + ); + assert!(values.contains(&VerifierScalarValuePlan::new( + "stage5.output.eq", + VerifierScalarValueKind::StructuredPolynomialEval + ))); + assert!(values.contains(&VerifierScalarValuePlan::new( + "stage5.output.sum", + VerifierScalarValueKind::ScalarExpr + ))); + assert!(values.contains(&VerifierScalarValuePlan::new( + "stage5.local.lookup", + VerifierScalarValueKind::RelationOutputLocal + ))); + Ok(()) + } + + fn structured_polynomial_eval(symbol: &str) -> StructuredPolynomialEvalPlan { + StructuredPolynomialEvalPlan { + symbol: symbol.to_owned(), + polynomial: StructuredPolynomialKind::Eq, + x_point: structured_polynomial_point("point.x"), + y_point: structured_polynomial_point("point.y"), + } + } + + fn structured_polynomial_point(source: &str) -> StructuredPolynomialPointPlan { + StructuredPolynomialPointPlan { + source: source.to_owned(), + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + } + } + + fn stage5_local_input_plan() -> Stage5InstructionReadRafEmitPlan { + Stage5InstructionReadRafEmitPlan { + point: "stage5.point".to_owned(), + lookup_output_point: "stage2.lookup_output".to_owned(), + table_flag_evals: IndexedEvalFamilyPlan { + symbol: "table.flags".to_owned(), + evals: Vec::new(), + }, + table_flag_evals_ref: "&TABLE_FLAGS".to_owned(), + instruction_ra_evals: IndexedEvalFamilyPlan { + symbol: "instruction.ra".to_owned(), + evals: Vec::new(), + }, + instruction_ra_evals_ref: "&INSTRUCTION_RA".to_owned(), + raf_flag_eval: "raf.flag".to_owned(), + gamma: "gamma".to_owned(), + local_scalars: vec![JoltLocalScalarEmitPlan { + symbol: "stage5.local.lookup".to_owned(), + kind: JoltLocalScalarMleKind::LookupTable { index: 0 }, + }], + log_k: 128, + } + } +} diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index b256ec9993..4ec8e3b835 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -9,6 +9,7 @@ pub enum VerifierScalarSourceKind { TranscriptScalar, FieldExpr, ScalarExpr, + StructuredPolynomialEval, RelationOutputLocal, SumcheckEval, OutputEvalFamily, @@ -16,6 +17,54 @@ pub enum VerifierScalarSourceKind { OutputFunctionFamily, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum VerifierScalarValueKind { + OpeningInput, + FieldConstant, + TranscriptScalar, + FieldExpr, + ScalarExpr, + StructuredPolynomialEval, + RelationOutputLocal, + SumcheckEval, + OutputEvalFamily, + OutputProductFamily, + OutputFunctionFamily, +} + +impl VerifierScalarValueKind { + fn source_kind(self) -> VerifierScalarSourceKind { + match self { + Self::OpeningInput => VerifierScalarSourceKind::OpeningInput, + Self::FieldConstant => VerifierScalarSourceKind::FieldConstant, + Self::TranscriptScalar => VerifierScalarSourceKind::TranscriptScalar, + Self::FieldExpr => VerifierScalarSourceKind::FieldExpr, + Self::ScalarExpr => VerifierScalarSourceKind::ScalarExpr, + Self::StructuredPolynomialEval => VerifierScalarSourceKind::StructuredPolynomialEval, + Self::RelationOutputLocal => VerifierScalarSourceKind::RelationOutputLocal, + Self::SumcheckEval => VerifierScalarSourceKind::SumcheckEval, + Self::OutputEvalFamily => VerifierScalarSourceKind::OutputEvalFamily, + Self::OutputProductFamily => VerifierScalarSourceKind::OutputProductFamily, + Self::OutputFunctionFamily => VerifierScalarSourceKind::OutputFunctionFamily, + } + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierScalarValuePlan { + pub(crate) symbol: String, + pub(crate) kind: VerifierScalarValueKind, +} + +impl VerifierScalarValuePlan { + pub(crate) fn new(symbol: impl Into, kind: VerifierScalarValueKind) -> Self { + Self { + symbol: symbol.into(), + kind, + } + } +} + #[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct VerifierScalarSourceSet { symbols: BTreeMap, @@ -41,6 +90,19 @@ impl VerifierScalarSourceSet { } } + pub(crate) fn insert_plan(&mut self, plan: &VerifierScalarValuePlan) { + self.insert(&plan.symbol, plan.kind.source_kind()); + } + + pub(crate) fn extend_plans<'a>( + &mut self, + plans: impl IntoIterator, + ) { + for plan in plans { + self.insert_plan(plan); + } + } + pub fn extend<'a>( &mut self, symbols: impl IntoIterator, From 8da38e67c6dc849a31e21741ef02b95ee7c90933 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 08:51:09 -0600 Subject: [PATCH 148/171] refactor(verifier): type relation local scalars Route relation-output local scalar lists through VerifierScalarValuePlan rows while preserving the generated verifier runtime string-slice surface. Update Stage 2, Stage 5, Stage 6, validation, and generated-plan adapters to consume the typed relation-output contract. --- .../jolt/emit/rust/relation_outputs.rs | 14 ++--- .../src/protocols/jolt/emit/rust/stage2.rs | 51 ++++++++-------- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../src/protocols/jolt/emit/rust/stage6.rs | 2 +- .../jolt/stage5_instruction_read_raf_plan.rs | 20 +++---- .../jolt/stage6_bytecode_read_raf_plan.rs | 12 ++-- .../jolt/verifier_relation_outputs.rs | 58 +++++++++++++++---- .../src/protocols/jolt/verifier_values.rs | 4 +- crates/jolt-equivalence/src/plan_adapters.rs | 8 ++- 9 files changed, 101 insertions(+), 70 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index 85954e1933..e854749f1f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -41,7 +41,11 @@ fn emit_local_scalar_constants( "{}_RELATION_OUTPUT_{claim_index}_LOCAL_SCALARS", stage_type.to_ascii_uppercase() ); - let scalars = rust_str_array(&claim.local_scalars); + let scalars = claim + .local_scalar_symbols() + .map(|symbol| rust_str(symbol)) + .collect::>() + .join(", "); push_format( source, format_args!("pub const {name}: &[&str] = &[{scalars}];\n"), @@ -52,11 +56,3 @@ fn emit_local_scalar_constants( fn rust_str(value: &str) -> String { format!("{value:?}") } - -fn rust_str_array(values: &[String]) -> String { - values - .iter() - .map(|value| rust_str(value)) - .collect::>() - .join(", ") -} diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 122a7c92a4..db2da59fea 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -423,35 +423,32 @@ fn stage2_relation_output_plans() -> Stage2RelationOutputRows { ), ], relation_outputs: vec![ - Stage2RelationOutputPlan { - relation: "jolt.stage2.ram.read_write".to_owned(), - local_scalars: Vec::new(), - expected_output: "stage2.ram_read_write.output.claim_expr".to_owned(), - }, - Stage2RelationOutputPlan { - relation: "jolt.stage2.instruction_lookup.claim_reduction".to_owned(), - local_scalars: Vec::new(), - expected_output: "stage2.instruction_lookup.output.claim_expr".to_owned(), - }, - Stage2RelationOutputPlan { - relation: "jolt.stage2.product_virtual.remainder".to_owned(), - local_scalars: Vec::new(), - expected_output: "stage2.product_virtual.remainder.output.claim_expr".to_owned(), - }, - Stage2RelationOutputPlan { - relation: "jolt.stage2.ram.raf_evaluation".to_owned(), - local_scalars: vec!["stage2.ram_raf.output.unmap".to_owned()], - expected_output: "stage2.ram_raf.output.claim_expr".to_owned(), - }, - Stage2RelationOutputPlan { - relation: "jolt.stage2.ram.output_check".to_owned(), - local_scalars: vec![ + Stage2RelationOutputPlan::new( + "jolt.stage2.ram.read_write", + "stage2.ram_read_write.output.claim_expr", + ), + Stage2RelationOutputPlan::new( + "jolt.stage2.instruction_lookup.claim_reduction", + "stage2.instruction_lookup.output.claim_expr", + ), + Stage2RelationOutputPlan::new( + "jolt.stage2.product_virtual.remainder", + "stage2.product_virtual.remainder.output.claim_expr", + ), + Stage2RelationOutputPlan::with_local_scalars( + "jolt.stage2.ram.raf_evaluation", + ["stage2.ram_raf.output.unmap".to_owned()], + "stage2.ram_raf.output.claim_expr", + ), + Stage2RelationOutputPlan::with_local_scalars( + "jolt.stage2.ram.output_check", + [ "stage2.ram_output.output.eq".to_owned(), "stage2.ram_output.output.io_mask".to_owned(), "stage2.ram_output.output.val_io".to_owned(), ], - expected_output: "stage2.ram_output.output.claim_expr".to_owned(), - }, + "stage2.ram_output.output.claim_expr", + ), ], } } @@ -1029,7 +1026,7 @@ impl Stage2CpuProgram { values.extend(symbols( self.relation_outputs .iter() - .flat_map(|output| output.local_scalars.iter()), + .flat_map(|output| output.local_scalar_symbols()), )); values.extend(symbols(self.evals.iter().map(|eval| &eval.symbol))); values @@ -1063,7 +1060,7 @@ impl Stage2CpuProgram { values.extend( self.relation_outputs .iter() - .flat_map(|output| output.local_scalars.iter()), + .flat_map(|output| output.local_scalar_symbols()), verifier_values::VerifierScalarSourceKind::RelationOutputLocal, ); values.extend( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 6620ae7ef5..f37623eb24 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -555,7 +555,7 @@ impl Stage5CpuProgram { values.extend( self.relation_outputs .iter() - .flat_map(|claim| claim.local_scalars.iter()), + .flat_map(|claim| claim.local_scalar_symbols()), verifier_values::VerifierScalarSourceKind::RelationOutputLocal, ); values.extend( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index ccfa080e7b..43b76768d6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -575,7 +575,7 @@ impl Stage6CpuProgram { values.extend( self.relation_outputs .iter() - .flat_map(|claim| claim.local_scalars.iter()), + .flat_map(|claim| claim.local_scalar_symbols()), verifier_values::VerifierScalarSourceKind::RelationOutputLocal, ); values.extend( diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index ca15f96df7..7d9c475376 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -209,15 +209,11 @@ impl Stage5InstructionReadRafEmitPlan { Stage5InstructionReadRafOutputPlan { relation_output_values: vec![eq.clone()], field_exprs, - claim: RelationOutputPlan { - relation: "jolt.stage5.instruction_read_raf".to_owned(), - local_scalars: self - .local_scalars - .iter() - .map(|value| value.symbol.clone()) - .collect(), - expected_output: claim_expr, - }, + claim: RelationOutputPlan::with_local_scalars( + "jolt.stage5.instruction_read_raf", + self.local_scalars.iter().map(|value| value.symbol.clone()), + claim_expr, + ), } } @@ -393,7 +389,11 @@ mod tests { "stage5.instruction_read_raf.output.eq.LookupOutputCycle" ); assert_eq!( - output_plan.claim.local_scalars, + output_plan + .claim + .local_scalar_symbols() + .cloned() + .collect::>(), vec![ "stage5.instruction_read_raf.local_scalar.LookupTable_0".to_owned(), "stage5.instruction_read_raf.local_scalar.LookupTable_1".to_owned(), diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 0c3806ebfb..ace6db1047 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -425,11 +425,11 @@ impl BytecodeReadRafPlan { operands: vec![self.output_contribution.to_owned(), bytecode_ra_product], }, ], - claim: RelationOutputPlan { - relation: "jolt.stage6.bytecode_read_raf".to_owned(), - local_scalars: output_term_symbols, - expected_output: claim_expr, - }, + claim: RelationOutputPlan::with_local_scalars( + "jolt.stage6.bytecode_read_raf", + output_term_symbols, + claim_expr, + ), } } } @@ -761,7 +761,7 @@ mod tests { "stage6.bytecode_read_raf.output.claim_expr" ); assert_eq!( - claim.local_scalars, + claim.local_scalar_symbols().cloned().collect::>(), vec![ "stage6.bytecode_read_raf.output.term.Stage1".to_owned(), "stage6.bytecode_read_raf.output.term.Stage2".to_owned(), diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 94fed5fcf7..e60db5395f 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -12,6 +12,7 @@ use crate::protocols::jolt::rust_target_plan::{ power_strided_weighted_sum_formula, structured_polynomial_scalar_formula, }; use crate::protocols::jolt::verifier_values::{VerifierPointSourceSet, VerifierScalarSourceSet}; +use crate::protocols::jolt::verifier_values::{VerifierScalarValueKind, VerifierScalarValuePlan}; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum StructuredPolynomialKind { @@ -295,10 +296,44 @@ pub struct RelationOutputFunctionFamilyPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: String, - pub local_scalars: Vec, + pub local_scalars: Vec, pub expected_output: String, } +impl RelationOutputPlan { + pub fn new(relation: impl Into, expected_output: impl Into) -> Self { + Self { + relation: relation.into(), + local_scalars: Vec::new(), + expected_output: expected_output.into(), + } + } + + pub(crate) fn with_local_scalars( + relation: impl Into, + local_scalars: impl IntoIterator, + expected_output: impl Into, + ) -> Self { + Self { + relation: relation.into(), + local_scalars: local_scalars + .into_iter() + .map(|symbol| { + VerifierScalarValuePlan::new( + symbol, + VerifierScalarValueKind::RelationOutputLocal, + ) + }) + .collect(), + expected_output: expected_output.into(), + } + } + + pub fn local_scalar_symbols(&self) -> impl Iterator { + self.local_scalars.iter().map(|value| &value.symbol) + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputAst { pub relation: String, @@ -1086,11 +1121,10 @@ where claim.relation ))); } - Ok(RelationOutputPlan { - relation: claim.relation, - local_scalars: Vec::new(), - expected_output: claim.expected_output, - }) + Ok(RelationOutputPlan::new( + claim.relation, + claim.expected_output, + )) }) .collect() } @@ -1443,7 +1477,7 @@ pub fn verify_relation_outputs( claim.relation, claim.expected_output ))); } - for local_scalar in &claim.local_scalars { + for local_scalar in claim.local_scalar_symbols() { if !field_values.contains(local_scalar) { return Err(EmitError::new(format!( "{stage} relation output for @{} references missing local scalar @{}", @@ -1819,11 +1853,11 @@ mod tests { field_values.insert("claim", VerifierScalarSourceKind::FieldExpr); let point_values = VerifierPointSourceSet::default(); let relations = BTreeSet::from(["relation".to_owned()]); - let relation_outputs = [RelationOutputPlan { - relation: "relation".to_owned(), - local_scalars: vec!["local.scalar".to_owned()], - expected_output: "claim".to_owned(), - }]; + let relation_outputs = [RelationOutputPlan::with_local_scalars( + "relation", + ["local.scalar".to_owned()], + "claim", + )]; let error = match verify_relation_outputs( "stage", diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 4ec8e3b835..934e0e9876 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -18,7 +18,7 @@ pub enum VerifierScalarSourceKind { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub(crate) enum VerifierScalarValueKind { +pub enum VerifierScalarValueKind { OpeningInput, FieldConstant, TranscriptScalar, @@ -51,7 +51,7 @@ impl VerifierScalarValueKind { } #[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct VerifierScalarValuePlan { +pub struct VerifierScalarValuePlan { pub(crate) symbol: String, pub(crate) kind: VerifierScalarValueKind, } diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index 14b89d8fac..f941ea2e59 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -796,7 +796,7 @@ macro_rules! define_stage_adapter_impl { .iter() .map(|plan| $module::$relation_output { relation: super::generated_relation_kind(&plan.relation), - local_scalars: super::leak_str_slice(&plan.local_scalars), + local_scalars: super::leak_str_iter(plan.local_scalar_symbols()), expected_output: super::leak_str(&plan.expected_output), }) .collect(), @@ -1826,8 +1826,12 @@ fn leak_str(value: &str) -> &'static str { } fn leak_str_slice(values: &[String]) -> &'static [&'static str] { + leak_str_iter(values.iter()) +} + +fn leak_str_iter<'a>(values: impl IntoIterator) -> &'static [&'static str] { let leaked = values - .iter() + .into_iter() .map(|value| leak_str(value)) .collect::>(); Box::leak(leaked.into_boxed_slice()) From 0835faa05eccca9dcd90f7086ae95231f40976ae Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 08:53:06 -0600 Subject: [PATCH 149/171] refactor(verifier): hide relation scalar storage Keep relation-output local scalar rows behind constructor and accessor methods, and narrow scalar-value row types back to crate-local visibility. --- .../bolt/src/protocols/jolt/emit/rust/relation_outputs.rs | 2 +- crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs | 6 +++++- crates/bolt/src/protocols/jolt/verifier_values.rs | 4 ++-- 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index e854749f1f..afb35f9843 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -34,7 +34,7 @@ fn emit_local_scalar_constants( claim_index: usize, claim: &RelationOutputPlan, ) -> String { - if claim.local_scalars.is_empty() { + if !claim.has_local_scalars() { return "&[]".to_owned(); } let name = format!( diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index e60db5395f..e0ea2eac7e 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -296,7 +296,7 @@ pub struct RelationOutputFunctionFamilyPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { pub relation: String, - pub local_scalars: Vec, + local_scalars: Vec, pub expected_output: String, } @@ -332,6 +332,10 @@ impl RelationOutputPlan { pub fn local_scalar_symbols(&self) -> impl Iterator { self.local_scalars.iter().map(|value| &value.symbol) } + + pub fn has_local_scalars(&self) -> bool { + !self.local_scalars.is_empty() + } } #[derive(Clone, Debug, PartialEq, Eq)] diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 934e0e9876..4ec8e3b835 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -18,7 +18,7 @@ pub enum VerifierScalarSourceKind { } #[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum VerifierScalarValueKind { +pub(crate) enum VerifierScalarValueKind { OpeningInput, FieldConstant, TranscriptScalar, @@ -51,7 +51,7 @@ impl VerifierScalarValueKind { } #[derive(Clone, Debug, PartialEq, Eq)] -pub struct VerifierScalarValuePlan { +pub(crate) struct VerifierScalarValuePlan { pub(crate) symbol: String, pub(crate) kind: VerifierScalarValueKind, } From 8b31dac02f1934b41b49ce962da14d6f76df1e61 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 08:58:22 -0600 Subject: [PATCH 150/171] refactor(verifier): type relation output refs Represent resolved relation-output expected values as typed scalar references and route emission, adapters, and tests through the accessor contract. --- .../jolt/emit/rust/relation_outputs.rs | 2 +- .../jolt/stage5_instruction_read_raf_plan.rs | 2 +- .../jolt/stage6_bytecode_read_raf_plan.rs | 2 +- .../jolt/verifier_relation_outputs.rs | 19 +++++++++++----- .../src/protocols/jolt/verifier_values.rs | 17 ++++++++++++++ crates/bolt/tests/commitment_ir.rs | 22 +++++++++++++------ crates/jolt-equivalence/src/plan_adapters.rs | 2 +- 7 files changed, 49 insertions(+), 17 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index afb35f9843..b5afceea72 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -14,7 +14,7 @@ pub fn emit_verifier_relation_output_constants( claims.push(format!( " {stage_type}RelationOutputPlan {{ relation: {}, local_scalars: {local_scalars}, expected_output: {} }},", super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, - rust_str(&claim.expected_output) + rust_str(claim.expected_output_symbol()) )); } let claims = claims.join("\n"); diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index 7d9c475376..e29e467dc6 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -380,7 +380,7 @@ mod tests { "jolt.stage5.instruction_read_raf" ); assert_eq!( - output_plan.claim.expected_output, + output_plan.claim.expected_output_symbol(), "stage5.instruction_read_raf.output.claim_expr" ); assert_eq!(output_plan.relation_output_values.len(), 1); diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index ace6db1047..51f534be8f 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -757,7 +757,7 @@ mod tests { assert_eq!(claim.relation, "jolt.stage6.bytecode_read_raf"); assert_eq!( - claim.expected_output, + claim.expected_output_symbol(), "stage6.bytecode_read_raf.output.claim_expr" ); assert_eq!( diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index e0ea2eac7e..ba4840d9c5 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -12,7 +12,9 @@ use crate::protocols::jolt::rust_target_plan::{ power_strided_weighted_sum_formula, structured_polynomial_scalar_formula, }; use crate::protocols::jolt::verifier_values::{VerifierPointSourceSet, VerifierScalarSourceSet}; -use crate::protocols::jolt::verifier_values::{VerifierScalarValueKind, VerifierScalarValuePlan}; +use crate::protocols::jolt::verifier_values::{ + VerifierScalarValueKind, VerifierScalarValuePlan, VerifierScalarValueRef, +}; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum StructuredPolynomialKind { @@ -297,7 +299,7 @@ pub struct RelationOutputFunctionFamilyPlan { pub struct RelationOutputPlan { pub relation: String, local_scalars: Vec, - pub expected_output: String, + expected_output: VerifierScalarValueRef, } impl RelationOutputPlan { @@ -305,7 +307,7 @@ impl RelationOutputPlan { Self { relation: relation.into(), local_scalars: Vec::new(), - expected_output: expected_output.into(), + expected_output: VerifierScalarValueRef::new(expected_output), } } @@ -325,7 +327,7 @@ impl RelationOutputPlan { ) }) .collect(), - expected_output: expected_output.into(), + expected_output: VerifierScalarValueRef::new(expected_output), } } @@ -336,6 +338,10 @@ impl RelationOutputPlan { pub fn has_local_scalars(&self) -> bool { !self.local_scalars.is_empty() } + + pub fn expected_output_symbol(&self) -> &str { + self.expected_output.symbol() + } } #[derive(Clone, Debug, PartialEq, Eq)] @@ -1475,10 +1481,11 @@ pub fn verify_relation_outputs( claim.relation ))); } - if !field_values.contains(&claim.expected_output) { + let expected_output = claim.expected_output_symbol(); + if !field_values.contains(expected_output) { return Err(EmitError::new(format!( "{stage} relation output for @{} uses missing expected output @{}", - claim.relation, claim.expected_output + claim.relation, expected_output ))); } for local_scalar in claim.local_scalar_symbols() { diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 4ec8e3b835..f3ff79f52c 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -65,6 +65,23 @@ impl VerifierScalarValuePlan { } } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct VerifierScalarValueRef { + symbol: String, +} + +impl VerifierScalarValueRef { + pub(crate) fn new(symbol: impl Into) -> Self { + Self { + symbol: symbol.into(), + } + } + + pub(crate) fn symbol(&self) -> &str { + &self.symbol + } +} + #[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct VerifierScalarSourceSet { symbols: BTreeMap, diff --git a/crates/bolt/tests/commitment_ir.rs b/crates/bolt/tests/commitment_ir.rs index c9217f406a..a230ddd9fd 100644 --- a/crates/bolt/tests/commitment_ir.rs +++ b/crates/bolt/tests/commitment_ir.rs @@ -1722,13 +1722,15 @@ fn stage6_rust_targets_extract_and_compile() { let inc_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.inc_claim_reduction.output.claim_expr") + .filter(|claim| { + claim.expected_output_symbol() == "stage6.inc_claim_reduction.output.claim_expr" + }) .collect::>(); assert_eq!(inc_claims.len(), 1); let booleanity_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.booleanity.output.claim_expr") + .filter(|claim| claim.expected_output_symbol() == "stage6.booleanity.output.claim_expr") .collect::>(); assert_eq!(booleanity_claims.len(), 1); assert!(verifier_program @@ -1738,25 +1740,31 @@ fn stage6_rust_targets_extract_and_compile() { let hamming_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.hamming_booleanity.output.claim_expr") + .filter(|claim| { + claim.expected_output_symbol() == "stage6.hamming_booleanity.output.claim_expr" + }) .collect::>(); assert_eq!(hamming_claims.len(), 1); let ram_ra_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.ram_ra_virtual.output.claim_expr") + .filter(|claim| claim.expected_output_symbol() == "stage6.ram_ra_virtual.output.claim_expr") .collect::>(); assert_eq!(ram_ra_claims.len(), 1); let instruction_ra_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.instruction_ra_virtual.output.claim_expr") + .filter(|claim| { + claim.expected_output_symbol() == "stage6.instruction_ra_virtual.output.claim_expr" + }) .collect::>(); assert_eq!(instruction_ra_claims.len(), 1); let bytecode_claims = verifier_program .relation_outputs .iter() - .filter(|claim| claim.expected_output == "stage6.bytecode_read_raf.output.claim_expr") + .filter(|claim| { + claim.expected_output_symbol() == "stage6.bytecode_read_raf.output.claim_expr" + }) .collect::>(); assert_eq!(bytecode_claims.len(), 1); let bytecode_output_scalar_exprs = verifier_program @@ -2064,7 +2072,7 @@ fn stage7_rust_targets_extract_and_compile() { assert!(verifier_program.relation_output_eval_families.is_empty()); assert_eq!(verifier_program.relation_outputs.len(), 1); assert_eq!( - verifier_program.relation_outputs[0].expected_output, + verifier_program.relation_outputs[0].expected_output_symbol(), "stage7.hamming_weight_claim_reduction.output.claim_expr" ); let input_claim = verifier_program diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index f941ea2e59..e9b8b59282 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -797,7 +797,7 @@ macro_rules! define_stage_adapter_impl { .map(|plan| $module::$relation_output { relation: super::generated_relation_kind(&plan.relation), local_scalars: super::leak_str_iter(plan.local_scalar_symbols()), - expected_output: super::leak_str(&plan.expected_output), + expected_output: super::leak_str(plan.expected_output_symbol()), }) .collect(), ), From 8fc94abdcd06375a47a18a09c59cd9d57d52acca Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 09:07:48 -0600 Subject: [PATCH 151/171] refactor(verifier): validate relation value refs Add a typed scalar value set for verifier-stage plans and validate relation-output refs and local scalar plans against it instead of a flattened scalar source set. --- .../src/protocols/jolt/emit/rust/stage3.rs | 2 +- .../src/protocols/jolt/emit/rust/stage4.rs | 2 +- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../src/protocols/jolt/emit/rust/stage6.rs | 2 +- .../src/protocols/jolt/emit/rust/stage7.rs | 2 +- .../bolt/src/protocols/jolt/verifier_plan.rs | 10 +- .../jolt/verifier_relation_outputs.rs | 94 +++++++++++++------ .../src/protocols/jolt/verifier_values.rs | 67 +++++++++++-- 8 files changed, 140 insertions(+), 41 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index c1279f8a65..0f94b68de4 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -614,7 +614,7 @@ impl Stage3CpuProgram { .map(|instance| &instance.relation), ); let plan = self.verifier_plan()?; - let field_values = plan.scalar_value_sources(); + let field_values = plan.scalar_values(); let point_values = plan.point_value_sources(); verifier_relation_outputs::verify_relation_outputs( "stage3", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index d0b0a3b0fb..c18c5a8650 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -636,7 +636,7 @@ impl Stage4CpuProgram { .map(|instance| &instance.relation), ); let plan = self.verifier_plan()?; - let field_values = plan.scalar_value_sources(); + let field_values = plan.scalar_values(); let point_values = plan.point_value_sources(); verifier_relation_outputs::verify_relation_outputs( "stage4", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index f37623eb24..076c0a2fdc 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -745,7 +745,7 @@ impl Stage5CpuProgram { .map(|instance| &instance.relation), ); let plan = self.verifier_plan()?; - let field_values = plan.scalar_value_sources(); + let field_values = plan.scalar_values(); let point_values = plan.point_value_sources(); verifier_relation_outputs::verify_relation_outputs( "stage5", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 43b76768d6..30ecc65638 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -759,7 +759,7 @@ impl Stage6CpuProgram { .map(|instance| &instance.relation), ); let plan = self.verifier_plan()?; - let field_values = plan.scalar_value_sources(); + let field_values = plan.scalar_values(); let point_values = plan.point_value_sources(); verifier_relation_outputs::verify_relation_outputs( "stage6", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index ad2ae73fc4..9995260fe5 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -852,7 +852,7 @@ impl Stage7CpuProgram { .map(|instance| &instance.relation), ); let plan = self.verifier_plan()?; - let field_values = plan.scalar_value_sources(); + let field_values = plan.scalar_values(); let point_values = plan.point_value_sources(); verifier_relation_outputs::verify_relation_outputs( "stage7", diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 3d43df5035..3a0044ce39 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -32,7 +32,7 @@ use crate::protocols::jolt::verifier_value_rows::{ use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorSourceKind, VerifierFieldVectorSourceSet, VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarSourceSet, VerifierScalarValueKind, - VerifierScalarValuePlan, + VerifierScalarValuePlan, VerifierScalarValueSet, }; #[derive(Clone, Debug, PartialEq, Eq)] @@ -502,13 +502,17 @@ impl VerifierStagePlan { values } - pub(crate) fn scalar_value_sources(&self) -> VerifierScalarSourceSet { - let mut values = VerifierScalarSourceSet::default(); + pub(crate) fn scalar_values(&self) -> VerifierScalarValueSet { + let mut values = VerifierScalarValueSet::default(); let plans = self.scalar_value_plans(); values.extend_plans(&plans); values } + pub(crate) fn scalar_value_sources(&self) -> VerifierScalarSourceSet { + self.scalar_values().source_set() + } + pub(crate) fn field_vector_value_sources(&self) -> VerifierFieldVectorSourceSet { let mut values = VerifierFieldVectorSourceSet::default(); values.extend( diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index ba4840d9c5..3d2cc3d510 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -11,9 +11,9 @@ use crate::protocols::jolt::cpu_attrs::{ use crate::protocols::jolt::rust_target_plan::{ power_strided_weighted_sum_formula, structured_polynomial_scalar_formula, }; -use crate::protocols::jolt::verifier_values::{VerifierPointSourceSet, VerifierScalarSourceSet}; use crate::protocols::jolt::verifier_values::{ - VerifierScalarValueKind, VerifierScalarValuePlan, VerifierScalarValueRef, + VerifierPointSourceSet, VerifierScalarValueKind, VerifierScalarValuePlan, + VerifierScalarValueRef, VerifierScalarValueSet, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -1340,7 +1340,7 @@ pub struct RelationOutputVerification<'a> { pub relation_output_function_families: &'a [RelationOutputFunctionFamilyPlan], pub relation_outputs: &'a [RelationOutputPlan], pub relations: &'a BTreeSet, - pub field_values: &'a VerifierScalarSourceSet, + pub field_values: &'a VerifierScalarValueSet, pub point_values: &'a VerifierPointSourceSet, } @@ -1375,14 +1375,14 @@ pub fn verify_relation_outputs( } } for family in relation_output_eval_families { - if !field_values.contains(&family.gamma) { + if !field_values.contains_symbol(&family.gamma) { return Err(EmitError::new(format!( "{stage} relation output eval family @{} references missing gamma @{}", family.symbol, family.gamma ))); } for eval in &family.evals { - if !field_values.contains(eval) { + if !field_values.contains_symbol(eval) { return Err(EmitError::new(format!( "{stage} relation output eval family @{} references missing eval @{}", family.symbol, eval @@ -1390,7 +1390,7 @@ pub fn verify_relation_outputs( } } for term in &family.shared_terms { - if !field_values.contains(&term.factor) { + if !field_values.contains_symbol(&term.factor) { return Err(EmitError::new(format!( "{stage} relation output eval family @{} references missing shared factor @{}", family.symbol, term.factor @@ -1405,7 +1405,7 @@ pub fn verify_relation_outputs( term.factors.len(), )?; for factor in &term.factors { - if !field_values.contains(factor) { + if !field_values.contains_symbol(factor) { return Err(EmitError::new(format!( "{stage} relation output eval family @{} references missing item factor @{}", family.symbol, factor @@ -1416,7 +1416,7 @@ pub fn verify_relation_outputs( } for family in relation_output_product_families { if let Some(gamma) = &family.gamma { - if !field_values.contains(gamma) { + if !field_values.contains_symbol(gamma) { return Err(EmitError::new(format!( "{stage} relation output product family @{} references missing gamma @{}", family.symbol, gamma @@ -1431,7 +1431,7 @@ pub fn verify_relation_outputs( ))); } for eval in &term.evals { - if !field_values.contains(eval) { + if !field_values.contains_symbol(eval) { return Err(EmitError::new(format!( "{stage} relation output product family @{} references missing eval @{}", family.symbol, eval @@ -1439,7 +1439,7 @@ pub fn verify_relation_outputs( } } for factor in &term.factors { - if !field_values.contains(factor) { + if !field_values.contains_symbol(factor) { return Err(EmitError::new(format!( "{stage} relation output product family @{} references missing factor @{}", family.symbol, factor @@ -1450,7 +1450,7 @@ pub fn verify_relation_outputs( } for family in relation_output_function_families { if let Some(gamma) = &family.gamma { - if !field_values.contains(gamma) { + if !field_values.contains_symbol(gamma) { return Err(EmitError::new(format!( "{stage} relation output function family @{} references missing gamma @{}", family.symbol, gamma @@ -1458,14 +1458,14 @@ pub fn verify_relation_outputs( } } for term in &family.terms { - if !field_values.contains(&term.eval) { + if !field_values.contains_symbol(&term.eval) { return Err(EmitError::new(format!( "{stage} relation output function family @{} references missing eval @{}", family.symbol, term.eval ))); } for factor in &term.factors { - if !field_values.contains(factor) { + if !field_values.contains_symbol(factor) { return Err(EmitError::new(format!( "{stage} relation output function family @{} references missing factor @{}", family.symbol, factor @@ -1482,17 +1482,17 @@ pub fn verify_relation_outputs( ))); } let expected_output = claim.expected_output_symbol(); - if !field_values.contains(expected_output) { + if !field_values.contains_ref(&claim.expected_output) { return Err(EmitError::new(format!( "{stage} relation output for @{} uses missing expected output @{}", claim.relation, expected_output ))); } - for local_scalar in claim.local_scalar_symbols() { - if !field_values.contains(local_scalar) { + for local_scalar in &claim.local_scalars { + if !field_values.contains_plan(local_scalar) { return Err(EmitError::new(format!( "{stage} relation output for @{} references missing local scalar @{}", - claim.relation, local_scalar + claim.relation, local_scalar.symbol ))); } } @@ -1567,8 +1567,8 @@ mod tests { use crate::emit::rust::EmitError; use crate::protocols::jolt::verifier_values::{ - VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarSourceKind, - VerifierScalarSourceSet, + VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarValueKind, + VerifierScalarValueSet, }; use super::{ @@ -1789,10 +1789,10 @@ mod tests { } #[test] - fn relation_output_verification_rejects_conflicting_scalar_sources() -> Result<(), EmitError> { - let mut field_values = VerifierScalarSourceSet::default(); - field_values.insert("value", VerifierScalarSourceKind::OpeningInput); - field_values.insert("value", VerifierScalarSourceKind::FieldExpr); + fn relation_output_verification_rejects_conflicting_scalar_values() -> Result<(), EmitError> { + let mut field_values = VerifierScalarValueSet::default(); + field_values.insert("value", VerifierScalarValueKind::OpeningInput); + field_values.insert("value", VerifierScalarValueKind::FieldExpr); let point_values = VerifierPointSourceSet::default(); let relations = BTreeSet::new(); @@ -1818,14 +1818,14 @@ mod tests { }; assert!(error.to_string().contains( - "stage scalar source @value has conflicting kinds OpeningInput and FieldExpr" + "stage scalar value source @value has conflicting kinds OpeningInput and FieldExpr" )); Ok(()) } #[test] fn relation_output_verification_rejects_conflicting_point_sources() -> Result<(), EmitError> { - let field_values = VerifierScalarSourceSet::default(); + let field_values = VerifierScalarValueSet::default(); let mut point_values = VerifierPointSourceSet::default(); point_values.insert("point", VerifierPointSourceKind::OpeningInput); point_values.insert("point", VerifierPointSourceKind::PointExpr); @@ -1860,8 +1860,8 @@ mod tests { #[test] fn relation_output_verification_requires_planned_local_scalars() -> Result<(), EmitError> { - let mut field_values = VerifierScalarSourceSet::default(); - field_values.insert("claim", VerifierScalarSourceKind::FieldExpr); + let mut field_values = VerifierScalarValueSet::default(); + field_values.insert("claim", VerifierScalarValueKind::FieldExpr); let point_values = VerifierPointSourceSet::default(); let relations = BTreeSet::from(["relation".to_owned()]); let relation_outputs = [RelationOutputPlan::with_local_scalars( @@ -1896,4 +1896,44 @@ mod tests { )); Ok(()) } + + #[test] + fn relation_output_verification_requires_relation_local_scalar_kind() -> Result<(), EmitError> { + let mut field_values = VerifierScalarValueSet::default(); + field_values.insert("claim", VerifierScalarValueKind::FieldExpr); + field_values.insert("local.scalar", VerifierScalarValueKind::FieldExpr); + let point_values = VerifierPointSourceSet::default(); + let relations = BTreeSet::from(["relation".to_owned()]); + let relation_outputs = [RelationOutputPlan::with_local_scalars( + "relation", + ["local.scalar".to_owned()], + "claim", + )]; + + let error = match verify_relation_outputs( + "stage", + RelationOutputVerification { + relation_output_values: &[], + relation_output_eval_families: &[], + relation_output_product_families: &[], + relation_output_function_families: &[], + relation_outputs: &relation_outputs, + relations: &relations, + field_values: &field_values, + point_values: &point_values, + }, + ) { + Ok(()) => { + return Err(EmitError::new( + "wrong local scalar value kind should fail relation output verification", + )); + } + Err(error) => error, + }; + + assert!(error.to_string().contains( + "stage relation output for @relation references missing local scalar @local.scalar" + )); + Ok(()) + } } diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index f3ff79f52c..b28f0f7347 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -83,13 +83,13 @@ impl VerifierScalarValueRef { } #[derive(Clone, Debug, Default, PartialEq, Eq)] -pub struct VerifierScalarSourceSet { - symbols: BTreeMap, - conflicts: Vec>, +pub(crate) struct VerifierScalarValueSet { + symbols: BTreeMap, + conflicts: Vec>, } -impl VerifierScalarSourceSet { - pub fn insert(&mut self, symbol: &str, kind: VerifierScalarSourceKind) { +impl VerifierScalarValueSet { + pub(crate) fn insert(&mut self, symbol: &str, kind: VerifierScalarValueKind) { match self.symbols.entry(symbol.to_owned()) { std::collections::btree_map::Entry::Vacant(entry) => { let _entry = entry.insert(kind); @@ -108,7 +108,7 @@ impl VerifierScalarSourceSet { } pub(crate) fn insert_plan(&mut self, plan: &VerifierScalarValuePlan) { - self.insert(&plan.symbol, plan.kind.source_kind()); + self.insert(&plan.symbol, plan.kind); } pub(crate) fn extend_plans<'a>( @@ -120,6 +120,61 @@ impl VerifierScalarSourceSet { } } + pub(crate) fn contains_ref(&self, value_ref: &VerifierScalarValueRef) -> bool { + self.symbols.contains_key(value_ref.symbol()) + } + + pub(crate) fn contains_plan(&self, plan: &VerifierScalarValuePlan) -> bool { + self.symbols + .get(&plan.symbol) + .is_some_and(|kind| *kind == plan.kind) + } + + pub(crate) fn contains_symbol(&self, symbol: &str) -> bool { + self.symbols.contains_key(symbol) + } + + pub(crate) fn source_set(&self) -> VerifierScalarSourceSet { + let mut sources = VerifierScalarSourceSet::default(); + for (symbol, kind) in &self.symbols { + sources.insert(symbol, kind.source_kind()); + } + sources + } + + pub(crate) fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { + let Some(conflict) = self.conflicts.first() else { + return Ok(()); + }; + Err(conflicting_source_error(stage, "scalar value", conflict)) + } +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct VerifierScalarSourceSet { + symbols: BTreeMap, + conflicts: Vec>, +} + +impl VerifierScalarSourceSet { + pub fn insert(&mut self, symbol: &str, kind: VerifierScalarSourceKind) { + match self.symbols.entry(symbol.to_owned()) { + std::collections::btree_map::Entry::Vacant(entry) => { + let _entry = entry.insert(kind); + } + std::collections::btree_map::Entry::Occupied(entry) => { + let existing = *entry.get(); + if existing != kind { + self.conflicts.push(VerifierSourceConflict { + symbol: symbol.to_owned(), + existing, + incoming: kind, + }); + } + } + } + } + pub fn extend<'a>( &mut self, symbols: impl IntoIterator, From de955a24952328a0d443fb5df0871726eb5af211 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 09:26:34 -0600 Subject: [PATCH 152/171] refactor(verifier): type relation family scalars Represent resolved relation-output eval, product, and function family scalar operands as VerifierScalarValueRef values and validate them through the scalar value set. --- .../jolt/verifier_relation_outputs.rs | 245 ++++++++++++------ .../src/protocols/jolt/verifier_values.rs | 10 +- 2 files changed, 165 insertions(+), 90 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 3d2cc3d510..478fc6b286 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -245,20 +245,20 @@ pub fn structured_polynomial_scalar_expr_plan( #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputEvalFamilySharedTermPlan { pub gamma_power_offset: usize, - pub factor: String, + pub factor: VerifierScalarValueRef, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputEvalFamilyItemTermPlan { pub gamma_power_offset: usize, - pub factors: Vec, + pub factors: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputEvalFamilyPlan { pub symbol: String, - pub gamma: String, - pub evals: Vec, + pub gamma: VerifierScalarValueRef, + pub evals: Vec, pub power_stride: usize, pub value_term_offsets: Vec, pub shared_terms: Vec, @@ -268,15 +268,15 @@ pub struct RelationOutputEvalFamilyPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputProductFamilyTermPlan { pub gamma_power_offset: usize, - pub evals: Vec, + pub evals: Vec, pub eval_families: Vec, - pub factors: Vec, + pub factors: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputProductFamilyPlan { pub symbol: String, - pub gamma: Option, + pub gamma: Option, pub terms: Vec, } @@ -284,14 +284,14 @@ pub struct RelationOutputProductFamilyPlan { pub struct RelationOutputFunctionFamilyTermPlan { pub gamma_power_offset: usize, pub function: RelationOutputFunctionKind, - pub eval: String, - pub factors: Vec, + pub eval: VerifierScalarValueRef, + pub factors: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputFunctionFamilyPlan { pub symbol: String, - pub gamma: Option, + pub gamma: Option, pub terms: Vec, } @@ -369,6 +369,22 @@ impl FieldExprDependencies for RelationOutputFieldExprPlan { } } +fn scalar_ref(symbol: impl Into) -> VerifierScalarValueRef { + VerifierScalarValueRef::new(symbol) +} + +fn scalar_refs(symbols: impl IntoIterator) -> Vec { + symbols.into_iter().map(scalar_ref).collect() +} + +fn scalar_ref_symbols<'a>( + refs: impl IntoIterator, +) -> Vec { + refs.into_iter() + .map(|value_ref| value_ref.symbol().to_owned()) + .collect() +} + pub fn parse_output_eval_family_plan( stage: &str, operation: OperationRef<'_, '_>, @@ -419,7 +435,7 @@ pub fn parse_output_eval_family_plan( .map( |(gamma_power_offset, factor)| RelationOutputEvalFamilySharedTermPlan { gamma_power_offset, - factor, + factor: scalar_ref(factor), }, ) .collect(); @@ -429,13 +445,13 @@ pub fn parse_output_eval_family_plan( let end = start + evals.len(); item_terms.push(RelationOutputEvalFamilyItemTermPlan { gamma_power_offset, - factors: item_factors[start..end].to_vec(), + factors: scalar_refs(item_factors[start..end].to_vec()), }); } Ok(RelationOutputEvalFamilyPlan { symbol, - gamma, - evals, + gamma: scalar_ref(gamma), + evals: scalar_refs(evals), power_stride: int_attr(operation, "power_stride")?, value_term_offsets, shared_terms, @@ -517,16 +533,16 @@ pub fn parse_output_product_family_plan( let factor_end = factor_offset + factor_count; terms.push(RelationOutputProductFamilyTermPlan { gamma_power_offset, - evals: evals[eval_offset..eval_end].to_vec(), + evals: scalar_refs(evals[eval_offset..eval_end].to_vec()), eval_families: Vec::new(), - factors: factors[factor_offset..factor_end].to_vec(), + factors: scalar_refs(factors[factor_offset..factor_end].to_vec()), }); eval_offset = eval_end; factor_offset = factor_end; } Ok(RelationOutputProductFamilyPlan { symbol, - gamma: gamma.into_iter().next(), + gamma: gamma.into_iter().next().map(scalar_ref), terms, }) } @@ -604,14 +620,14 @@ pub fn parse_output_function_family_plan( "{stage} relation output function family @{symbol}: {error}" )) })?, - eval, - factors: factors[factor_offset..factor_end].to_vec(), + eval: scalar_ref(eval), + factors: scalar_refs(factors[factor_offset..factor_end].to_vec()), }); factor_offset = factor_end; } Ok(RelationOutputFunctionFamilyPlan { symbol, - gamma: gamma.into_iter().next(), + gamma: gamma.into_iter().next().map(scalar_ref), terms, }) } @@ -659,12 +675,12 @@ pub fn lower_boolean_zero_function_family_output( rows.push(relation_output_field_expr( square.clone(), "field.product", - vec![term.eval.clone(), term.eval.clone()], + vec![term.eval.symbol().to_owned(), term.eval.symbol().to_owned()], )); rows.push(relation_output_field_expr( boolean_zero.clone(), "field.sub", - vec![square, term.eval.clone()], + vec![square, term.eval.symbol().to_owned()], )); let mut operands = Vec::new(); if let Some(gamma) = &family.gamma { @@ -683,7 +699,7 @@ pub fn lower_boolean_zero_function_family_output( ))); } operands.push(boolean_zero); - operands.extend(term.factors.iter().cloned()); + operands.extend(scalar_ref_symbols(&term.factors)); push_relation_output_product_term( prefix, term_index, @@ -869,14 +885,19 @@ pub fn lower_eval_family_output_to_weighted_sum( + family.shared_terms.len() + family.evals.len() * family.item_terms.len(), ); - operands.push(family.gamma.clone()); - operands.extend(family.evals.iter().cloned()); - operands.extend(family.shared_terms.iter().map(|term| term.factor.clone())); + operands.push(family.gamma.symbol().to_owned()); + operands.extend(scalar_ref_symbols(&family.evals)); + operands.extend( + family + .shared_terms + .iter() + .map(|term| term.factor.symbol().to_owned()), + ); operands.extend( family .item_terms .iter() - .flat_map(|term| term.factors.iter().cloned()), + .flat_map(|term| term.factors.iter().map(|factor| factor.symbol().to_owned())), ); let formula = power_strided_weighted_sum_formula( family.evals.len(), @@ -945,8 +966,8 @@ pub fn lower_product_family_output( )); } } - operands.extend(term.evals.iter().cloned()); - operands.extend(term.factors.iter().cloned()); + operands.extend(scalar_ref_symbols(&term.evals)); + operands.extend(scalar_ref_symbols(&term.factors)); if operands.is_empty() { return Err(EmitError::new(format!( "{stage} relation output product family @{family_symbol} has an empty scalar term" @@ -973,15 +994,15 @@ pub fn lower_product_family_output( } fn eval_family_term_operands( - eval_symbol: &str, + eval_symbol: &VerifierScalarValueRef, gamma_power_offset: usize, - factor: Option<&String>, - gamma: &str, + factor: Option<&VerifierScalarValueRef>, + gamma: &VerifierScalarValueRef, prefix: &str, gamma_powers: &mut BTreeMap, rows: &mut Vec, ) -> Vec { - let mut operands = vec![eval_symbol.to_owned()]; + let mut operands = vec![eval_symbol.symbol().to_owned()]; if gamma_power_offset > 0 { operands.push(eval_family_gamma_power( gamma_power_offset, @@ -992,14 +1013,14 @@ fn eval_family_term_operands( )); } if let Some(factor) = factor { - operands.push(factor.clone()); + operands.push(factor.symbol().to_owned()); } operands } fn eval_family_gamma_power( exponent: usize, - gamma: &str, + gamma: &VerifierScalarValueRef, prefix: &str, gamma_powers: &mut BTreeMap, rows: &mut Vec, @@ -1011,7 +1032,7 @@ fn eval_family_gamma_power( rows.push(relation_output_field_expr( symbol.clone(), format!("field.pow:{exponent}"), - vec![gamma.to_owned()], + vec![gamma.symbol().to_owned()], )); let _old = gamma_powers.insert(exponent, symbol.clone()); symbol @@ -1226,14 +1247,14 @@ where relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, field_exprs_by_symbol, - &family.gamma, + family.gamma.symbol(), )); stack.extend(family.evals.iter().map(|eval| { output_dependency_node( relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, field_exprs_by_symbol, - eval, + eval.symbol(), ) })); stack.extend(family.shared_terms.iter().map(|term| { @@ -1241,7 +1262,7 @@ where relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, field_exprs_by_symbol, - &term.factor, + term.factor.symbol(), ) })); stack.extend(family.item_terms.iter().flat_map(|term| { @@ -1250,7 +1271,7 @@ where relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, field_exprs_by_symbol, - factor, + factor.symbol(), ) }) })); @@ -1268,7 +1289,7 @@ where relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, field_exprs_by_symbol, - gamma, + gamma.symbol(), ) })); for term in &family.terms { @@ -1277,7 +1298,7 @@ where relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, field_exprs_by_symbol, - eval, + eval.symbol(), ) })); stack.extend(term.factors.iter().map(|factor| { @@ -1285,7 +1306,7 @@ where relation_output_eval_families_by_symbol, relation_output_product_families_by_symbol, field_exprs_by_symbol, - factor, + factor.symbol(), ) })); } @@ -1375,25 +1396,28 @@ pub fn verify_relation_outputs( } } for family in relation_output_eval_families { - if !field_values.contains_symbol(&family.gamma) { + if !field_values.contains_ref(&family.gamma) { return Err(EmitError::new(format!( "{stage} relation output eval family @{} references missing gamma @{}", - family.symbol, family.gamma + family.symbol, + family.gamma.symbol() ))); } for eval in &family.evals { - if !field_values.contains_symbol(eval) { + if !field_values.contains_ref(eval) { return Err(EmitError::new(format!( "{stage} relation output eval family @{} references missing eval @{}", - family.symbol, eval + family.symbol, + eval.symbol() ))); } } for term in &family.shared_terms { - if !field_values.contains_symbol(&term.factor) { + if !field_values.contains_ref(&term.factor) { return Err(EmitError::new(format!( "{stage} relation output eval family @{} references missing shared factor @{}", - family.symbol, term.factor + family.symbol, + term.factor.symbol() ))); } } @@ -1405,10 +1429,11 @@ pub fn verify_relation_outputs( term.factors.len(), )?; for factor in &term.factors { - if !field_values.contains_symbol(factor) { + if !field_values.contains_ref(factor) { return Err(EmitError::new(format!( "{stage} relation output eval family @{} references missing item factor @{}", - family.symbol, factor + family.symbol, + factor.symbol() ))); } } @@ -1416,10 +1441,11 @@ pub fn verify_relation_outputs( } for family in relation_output_product_families { if let Some(gamma) = &family.gamma { - if !field_values.contains_symbol(gamma) { + if !field_values.contains_ref(gamma) { return Err(EmitError::new(format!( "{stage} relation output product family @{} references missing gamma @{}", - family.symbol, gamma + family.symbol, + gamma.symbol() ))); } } @@ -1431,18 +1457,20 @@ pub fn verify_relation_outputs( ))); } for eval in &term.evals { - if !field_values.contains_symbol(eval) { + if !field_values.contains_ref(eval) { return Err(EmitError::new(format!( "{stage} relation output product family @{} references missing eval @{}", - family.symbol, eval + family.symbol, + eval.symbol() ))); } } for factor in &term.factors { - if !field_values.contains_symbol(factor) { + if !field_values.contains_ref(factor) { return Err(EmitError::new(format!( "{stage} relation output product family @{} references missing factor @{}", - family.symbol, factor + family.symbol, + factor.symbol() ))); } } @@ -1450,25 +1478,28 @@ pub fn verify_relation_outputs( } for family in relation_output_function_families { if let Some(gamma) = &family.gamma { - if !field_values.contains_symbol(gamma) { + if !field_values.contains_ref(gamma) { return Err(EmitError::new(format!( "{stage} relation output function family @{} references missing gamma @{}", - family.symbol, gamma + family.symbol, + gamma.symbol() ))); } } for term in &family.terms { - if !field_values.contains_symbol(&term.eval) { + if !field_values.contains_ref(&term.eval) { return Err(EmitError::new(format!( "{stage} relation output function family @{} references missing eval @{}", - family.symbol, term.eval + family.symbol, + term.eval.symbol() ))); } for factor in &term.factors { - if !field_values.contains_symbol(factor) { + if !field_values.contains_ref(factor) { return Err(EmitError::new(format!( "{stage} relation output function family @{} references missing factor @{}", - family.symbol, factor + family.symbol, + factor.symbol() ))); } } @@ -1572,14 +1603,15 @@ mod tests { }; use super::{ - resolve_relation_outputs, verify_relation_outputs, FieldExprDependencies, - RelationOutputAst, RelationOutputEvalFamilyItemTermPlan, RelationOutputEvalFamilyPlan, - RelationOutputEvalFamilySharedTermPlan, RelationOutputFunctionFamilyPlan, - RelationOutputFunctionFamilyTermPlan, RelationOutputFunctionKind, RelationOutputPlan, - RelationOutputProductFamilyPlan, RelationOutputProductFamilyTermPlan, - RelationOutputVerification, StructuredPolynomialEvalPlan, StructuredPolynomialKind, - StructuredPolynomialPointLength, StructuredPolynomialPointOrder, - StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, + resolve_relation_outputs, scalar_ref, scalar_refs, verify_relation_outputs, + FieldExprDependencies, RelationOutputAst, RelationOutputEvalFamilyItemTermPlan, + RelationOutputEvalFamilyPlan, RelationOutputEvalFamilySharedTermPlan, + RelationOutputFunctionFamilyPlan, RelationOutputFunctionFamilyTermPlan, + RelationOutputFunctionKind, RelationOutputPlan, RelationOutputProductFamilyPlan, + RelationOutputProductFamilyTermPlan, RelationOutputVerification, + StructuredPolynomialEvalPlan, StructuredPolynomialKind, StructuredPolynomialPointLength, + StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, + StructuredPolynomialPointSegment, }; struct TestFieldExpr { @@ -1634,8 +1666,8 @@ mod tests { ) -> Result<(), EmitError> { let inner_family = RelationOutputEvalFamilyPlan { symbol: "inner.family".to_owned(), - gamma: "inner.gamma".to_owned(), - evals: vec!["inner.eval".to_owned()], + gamma: scalar_ref("inner.gamma"), + evals: scalar_refs(["inner.eval".to_owned()]), power_stride: 1, value_term_offsets: vec![0], shared_terms: Vec::new(), @@ -1643,17 +1675,17 @@ mod tests { }; let outer_family = RelationOutputEvalFamilyPlan { symbol: "outer.family".to_owned(), - gamma: "outer.gamma".to_owned(), - evals: vec!["outer.eval".to_owned()], + gamma: scalar_ref("outer.gamma"), + evals: scalar_refs(["outer.eval".to_owned()]), power_stride: 1, value_term_offsets: Vec::new(), shared_terms: vec![RelationOutputEvalFamilySharedTermPlan { gamma_power_offset: 0, - factor: "outer.shared.factor".to_owned(), + factor: scalar_ref("outer.shared.factor"), }], item_terms: vec![RelationOutputEvalFamilyItemTermPlan { gamma_power_offset: 1, - factors: vec!["factor.expr".to_owned()], + factors: scalar_refs(["factor.expr".to_owned()]), }], }; let field_exprs = vec![ @@ -1700,12 +1732,12 @@ mod tests { ) -> Result<(), EmitError> { let product_family = RelationOutputProductFamilyPlan { symbol: "product.family".to_owned(), - gamma: Some("product.gamma".to_owned()), + gamma: Some(scalar_ref("product.gamma")), terms: vec![RelationOutputProductFamilyTermPlan { gamma_power_offset: 2, - evals: vec!["product.eval".to_owned()], + evals: scalar_refs(["product.eval".to_owned()]), eval_families: Vec::new(), - factors: vec!["product.factor.expr".to_owned()], + factors: scalar_refs(["product.factor.expr".to_owned()]), }], }; let field_exprs = vec![ @@ -1751,12 +1783,12 @@ mod tests { fn resolve_rejects_unlowered_function_families() -> Result<(), EmitError> { let function_family = RelationOutputFunctionFamilyPlan { symbol: "function.family".to_owned(), - gamma: Some("function.gamma".to_owned()), + gamma: Some(scalar_ref("function.gamma")), terms: vec![RelationOutputFunctionFamilyTermPlan { gamma_power_offset: 0, function: RelationOutputFunctionKind::BooleanZero, - eval: "function.eval".to_owned(), - factors: vec!["function.factor.expr".to_owned()], + eval: scalar_ref("function.eval"), + factors: scalar_refs(["function.factor.expr".to_owned()]), }], }; let claim_asts = vec![RelationOutputAst { @@ -1897,6 +1929,53 @@ mod tests { Ok(()) } + #[test] + fn relation_output_verification_requires_planned_family_scalar_refs() -> Result<(), EmitError> { + let mut field_values = VerifierScalarValueSet::default(); + field_values.insert("family.gamma", VerifierScalarValueKind::TranscriptScalar); + field_values.insert("family.eval", VerifierScalarValueKind::SumcheckEval); + let point_values = VerifierPointSourceSet::default(); + let relations = BTreeSet::new(); + let family = RelationOutputEvalFamilyPlan { + symbol: "family".to_owned(), + gamma: scalar_ref("family.gamma"), + evals: scalar_refs(["family.eval".to_owned()]), + power_stride: 1, + value_term_offsets: Vec::new(), + shared_terms: vec![RelationOutputEvalFamilySharedTermPlan { + gamma_power_offset: 0, + factor: scalar_ref("missing.factor"), + }], + item_terms: Vec::new(), + }; + + let error = match verify_relation_outputs( + "stage", + RelationOutputVerification { + relation_output_values: &[], + relation_output_eval_families: &[family], + relation_output_product_families: &[], + relation_output_function_families: &[], + relation_outputs: &[], + relations: &relations, + field_values: &field_values, + point_values: &point_values, + }, + ) { + Ok(()) => { + return Err(EmitError::new( + "missing family scalar ref should fail relation output verification", + )); + } + Err(error) => error, + }; + + assert!(error.to_string().contains( + "stage relation output eval family @family references missing shared factor @missing.factor" + )); + Ok(()) + } + #[test] fn relation_output_verification_requires_relation_local_scalar_kind() -> Result<(), EmitError> { let mut field_values = VerifierScalarValueSet::default(); diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index b28f0f7347..597697f720 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -66,18 +66,18 @@ impl VerifierScalarValuePlan { } #[derive(Clone, Debug, PartialEq, Eq)] -pub(crate) struct VerifierScalarValueRef { +pub struct VerifierScalarValueRef { symbol: String, } impl VerifierScalarValueRef { - pub(crate) fn new(symbol: impl Into) -> Self { + pub fn new(symbol: impl Into) -> Self { Self { symbol: symbol.into(), } } - pub(crate) fn symbol(&self) -> &str { + pub fn symbol(&self) -> &str { &self.symbol } } @@ -130,10 +130,6 @@ impl VerifierScalarValueSet { .is_some_and(|kind| *kind == plan.kind) } - pub(crate) fn contains_symbol(&self, symbol: &str) -> bool { - self.symbols.contains_key(symbol) - } - pub(crate) fn source_set(&self) -> VerifierScalarSourceSet { let mut sources = VerifierScalarSourceSet::default(); for (symbol, kind) in &self.symbols { From e9e98f7b8e0605cb4a059bd0e72412b21e75d98e Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 09:49:53 -0600 Subject: [PATCH 153/171] refactor(verifier): type relation vector refs Represent relation-output product-family eval families with typed field-vector refs and validate them against indexed eval-family plan rows. --- .../src/protocols/jolt/emit/rust/stage3.rs | 2 + .../src/protocols/jolt/emit/rust/stage4.rs | 2 + .../src/protocols/jolt/emit/rust/stage5.rs | 2 + .../src/protocols/jolt/emit/rust/stage6.rs | 2 + .../src/protocols/jolt/emit/rust/stage7.rs | 2 + .../bolt/src/protocols/jolt/verifier_plan.rs | 26 +++--- .../jolt/verifier_relation_outputs.rs | 79 +++++++++++++++++-- .../src/protocols/jolt/verifier_values.rs | 66 +++++++++++++--- 8 files changed, 154 insertions(+), 27 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 0f94b68de4..9555d67e80 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -615,6 +615,7 @@ impl Stage3CpuProgram { ); let plan = self.verifier_plan()?; let field_values = plan.scalar_values(); + let field_vector_values = plan.field_vector_values(); let point_values = plan.point_value_sources(); verifier_relation_outputs::verify_relation_outputs( "stage3", @@ -626,6 +627,7 @@ impl Stage3CpuProgram { relation_outputs: &self.relation_outputs, relations: &relations, field_values: &field_values, + field_vector_values: &field_vector_values, point_values: &point_values, }, ) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index c18c5a8650..102d41de59 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -637,6 +637,7 @@ impl Stage4CpuProgram { ); let plan = self.verifier_plan()?; let field_values = plan.scalar_values(); + let field_vector_values = plan.field_vector_values(); let point_values = plan.point_value_sources(); verifier_relation_outputs::verify_relation_outputs( "stage4", @@ -648,6 +649,7 @@ impl Stage4CpuProgram { relation_outputs: &self.relation_outputs, relations: &relations, field_values: &field_values, + field_vector_values: &field_vector_values, point_values: &point_values, }, ) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 076c0a2fdc..57d9fb9362 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -746,6 +746,7 @@ impl Stage5CpuProgram { ); let plan = self.verifier_plan()?; let field_values = plan.scalar_values(); + let field_vector_values = plan.field_vector_values(); let point_values = plan.point_value_sources(); verifier_relation_outputs::verify_relation_outputs( "stage5", @@ -757,6 +758,7 @@ impl Stage5CpuProgram { relation_outputs: &self.relation_outputs, relations: &relations, field_values: &field_values, + field_vector_values: &field_vector_values, point_values: &point_values, }, ) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 30ecc65638..6bd716265e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -760,6 +760,7 @@ impl Stage6CpuProgram { ); let plan = self.verifier_plan()?; let field_values = plan.scalar_values(); + let field_vector_values = plan.field_vector_values(); let point_values = plan.point_value_sources(); verifier_relation_outputs::verify_relation_outputs( "stage6", @@ -771,6 +772,7 @@ impl Stage6CpuProgram { relation_outputs: &self.relation_outputs, relations: &relations, field_values: &field_values, + field_vector_values: &field_vector_values, point_values: &point_values, }, ) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 9995260fe5..e2bcc41e7d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -853,6 +853,7 @@ impl Stage7CpuProgram { ); let plan = self.verifier_plan()?; let field_values = plan.scalar_values(); + let field_vector_values = plan.field_vector_values(); let point_values = plan.point_value_sources(); verifier_relation_outputs::verify_relation_outputs( "stage7", @@ -864,6 +865,7 @@ impl Stage7CpuProgram { relation_outputs: &self.relation_outputs, relations: &relations, field_values: &field_values, + field_vector_values: &field_vector_values, point_values: &point_values, }, ) diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 3a0044ce39..1068f0edae 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -30,9 +30,9 @@ use crate::protocols::jolt::verifier_value_rows::{ CpuFieldConstantPlan, CpuFieldExprPlan, CpuScalarExprPlan, }; use crate::protocols::jolt::verifier_values::{ - VerifierFieldVectorSourceKind, VerifierFieldVectorSourceSet, VerifierPointSourceKind, - VerifierPointSourceSet, VerifierScalarSourceSet, VerifierScalarValueKind, - VerifierScalarValuePlan, VerifierScalarValueSet, + VerifierFieldVectorSourceSet, VerifierFieldVectorValueKind, VerifierFieldVectorValueSet, + VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarSourceSet, + VerifierScalarValueKind, VerifierScalarValuePlan, VerifierScalarValueSet, }; #[derive(Clone, Debug, PartialEq, Eq)] @@ -513,17 +513,21 @@ impl VerifierStagePlan { self.scalar_values().source_set() } - pub(crate) fn field_vector_value_sources(&self) -> VerifierFieldVectorSourceSet { - let mut values = VerifierFieldVectorSourceSet::default(); - values.extend( - self.indexed_eval_families - .iter() - .map(|family| &family.symbol), - VerifierFieldVectorSourceKind::IndexedEvalFamily, - ); + pub(crate) fn field_vector_values(&self) -> VerifierFieldVectorValueSet { + let mut values = VerifierFieldVectorValueSet::default(); + for family in &self.indexed_eval_families { + values.insert( + &family.symbol, + VerifierFieldVectorValueKind::IndexedEvalFamily, + ); + } values } + pub(crate) fn field_vector_value_sources(&self) -> VerifierFieldVectorSourceSet { + self.field_vector_values().source_set() + } + pub(crate) fn point_value_sources(&self) -> VerifierPointSourceSet { let mut values = VerifierPointSourceSet::default(); values.extend( diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 478fc6b286..ec9154b669 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -12,8 +12,9 @@ use crate::protocols::jolt::rust_target_plan::{ power_strided_weighted_sum_formula, structured_polynomial_scalar_formula, }; use crate::protocols::jolt::verifier_values::{ - VerifierPointSourceSet, VerifierScalarValueKind, VerifierScalarValuePlan, - VerifierScalarValueRef, VerifierScalarValueSet, + VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointSourceSet, + VerifierScalarValueKind, VerifierScalarValuePlan, VerifierScalarValueRef, + VerifierScalarValueSet, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -269,7 +270,7 @@ pub struct RelationOutputEvalFamilyPlan { pub struct RelationOutputProductFamilyTermPlan { pub gamma_power_offset: usize, pub evals: Vec, - pub eval_families: Vec, + pub eval_families: Vec, pub factors: Vec, } @@ -1362,6 +1363,7 @@ pub struct RelationOutputVerification<'a> { pub relation_outputs: &'a [RelationOutputPlan], pub relations: &'a BTreeSet, pub field_values: &'a VerifierScalarValueSet, + pub field_vector_values: &'a VerifierFieldVectorValueSet, pub point_values: &'a VerifierPointSourceSet, } @@ -1377,6 +1379,7 @@ pub fn verify_relation_outputs( relation_outputs, relations, field_values, + field_vector_values, point_values, } = verification; field_values.verify_no_conflicts(stage)?; @@ -1450,12 +1453,21 @@ pub fn verify_relation_outputs( } } for term in &family.terms { - if term.evals.is_empty() && term.factors.is_empty() { + if term.evals.is_empty() && term.eval_families.is_empty() && term.factors.is_empty() { return Err(EmitError::new(format!( "{stage} relation output product family @{} has an empty term", family.symbol ))); } + for eval_family in &term.eval_families { + if !field_vector_values.contains_ref(eval_family) { + return Err(EmitError::new(format!( + "{stage} relation output product family @{} references missing eval family @{}", + family.symbol, + eval_family.symbol() + ))); + } + } for eval in &term.evals { if !field_values.contains_ref(eval) { return Err(EmitError::new(format!( @@ -1598,8 +1610,8 @@ mod tests { use crate::emit::rust::EmitError; use crate::protocols::jolt::verifier_values::{ - VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarValueKind, - VerifierScalarValueSet, + VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointSourceKind, + VerifierPointSourceSet, VerifierScalarValueKind, VerifierScalarValueSet, }; use super::{ @@ -1825,6 +1837,7 @@ mod tests { let mut field_values = VerifierScalarValueSet::default(); field_values.insert("value", VerifierScalarValueKind::OpeningInput); field_values.insert("value", VerifierScalarValueKind::FieldExpr); + let field_vector_values = VerifierFieldVectorValueSet::default(); let point_values = VerifierPointSourceSet::default(); let relations = BTreeSet::new(); @@ -1838,6 +1851,7 @@ mod tests { relation_outputs: &[], relations: &relations, field_values: &field_values, + field_vector_values: &field_vector_values, point_values: &point_values, }, ) { @@ -1858,6 +1872,7 @@ mod tests { #[test] fn relation_output_verification_rejects_conflicting_point_sources() -> Result<(), EmitError> { let field_values = VerifierScalarValueSet::default(); + let field_vector_values = VerifierFieldVectorValueSet::default(); let mut point_values = VerifierPointSourceSet::default(); point_values.insert("point", VerifierPointSourceKind::OpeningInput); point_values.insert("point", VerifierPointSourceKind::PointExpr); @@ -1873,6 +1888,7 @@ mod tests { relation_outputs: &[], relations: &relations, field_values: &field_values, + field_vector_values: &field_vector_values, point_values: &point_values, }, ) { @@ -1894,6 +1910,7 @@ mod tests { fn relation_output_verification_requires_planned_local_scalars() -> Result<(), EmitError> { let mut field_values = VerifierScalarValueSet::default(); field_values.insert("claim", VerifierScalarValueKind::FieldExpr); + let field_vector_values = VerifierFieldVectorValueSet::default(); let point_values = VerifierPointSourceSet::default(); let relations = BTreeSet::from(["relation".to_owned()]); let relation_outputs = [RelationOutputPlan::with_local_scalars( @@ -1912,6 +1929,7 @@ mod tests { relation_outputs: &relation_outputs, relations: &relations, field_values: &field_values, + field_vector_values: &field_vector_values, point_values: &point_values, }, ) { @@ -1934,6 +1952,7 @@ mod tests { let mut field_values = VerifierScalarValueSet::default(); field_values.insert("family.gamma", VerifierScalarValueKind::TranscriptScalar); field_values.insert("family.eval", VerifierScalarValueKind::SumcheckEval); + let field_vector_values = VerifierFieldVectorValueSet::default(); let point_values = VerifierPointSourceSet::default(); let relations = BTreeSet::new(); let family = RelationOutputEvalFamilyPlan { @@ -1959,6 +1978,7 @@ mod tests { relation_outputs: &[], relations: &relations, field_values: &field_values, + field_vector_values: &field_vector_values, point_values: &point_values, }, ) { @@ -1976,11 +1996,57 @@ mod tests { Ok(()) } + #[test] + fn relation_output_verification_requires_planned_field_vector_refs() -> Result<(), EmitError> { + let field_values = VerifierScalarValueSet::default(); + let field_vector_values = VerifierFieldVectorValueSet::default(); + let point_values = VerifierPointSourceSet::default(); + let relations = BTreeSet::new(); + let family = RelationOutputProductFamilyPlan { + symbol: "product.family".to_owned(), + gamma: None, + terms: vec![RelationOutputProductFamilyTermPlan { + gamma_power_offset: 0, + evals: Vec::new(), + eval_families: vec![VerifierFieldVectorValueRef::new("missing.eval.family")], + factors: Vec::new(), + }], + }; + + let error = match verify_relation_outputs( + "stage", + RelationOutputVerification { + relation_output_values: &[], + relation_output_eval_families: &[], + relation_output_product_families: &[family], + relation_output_function_families: &[], + relation_outputs: &[], + relations: &relations, + field_values: &field_values, + field_vector_values: &field_vector_values, + point_values: &point_values, + }, + ) { + Ok(()) => { + return Err(EmitError::new( + "missing field-vector ref should fail relation output verification", + )); + } + Err(error) => error, + }; + + assert!(error.to_string().contains( + "stage relation output product family @product.family references missing eval family @missing.eval.family" + )); + Ok(()) + } + #[test] fn relation_output_verification_requires_relation_local_scalar_kind() -> Result<(), EmitError> { let mut field_values = VerifierScalarValueSet::default(); field_values.insert("claim", VerifierScalarValueKind::FieldExpr); field_values.insert("local.scalar", VerifierScalarValueKind::FieldExpr); + let field_vector_values = VerifierFieldVectorValueSet::default(); let point_values = VerifierPointSourceSet::default(); let relations = BTreeSet::from(["relation".to_owned()]); let relation_outputs = [RelationOutputPlan::with_local_scalars( @@ -1999,6 +2065,7 @@ mod tests { relation_outputs: &relation_outputs, relations: &relations, field_values: &field_values, + field_vector_values: &field_vector_values, point_values: &point_values, }, ) { diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 597697f720..a77a876f62 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -198,24 +198,70 @@ pub enum VerifierFieldVectorSourceKind { IndexedEvalFamily, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum VerifierFieldVectorValueKind { + IndexedEvalFamily, +} + +impl VerifierFieldVectorValueKind { + fn source_kind(self) -> VerifierFieldVectorSourceKind { + match self { + Self::IndexedEvalFamily => VerifierFieldVectorSourceKind::IndexedEvalFamily, + } + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct VerifierFieldVectorValueRef { + symbol: String, +} + +impl VerifierFieldVectorValueRef { + pub fn new(symbol: impl Into) -> Self { + Self { + symbol: symbol.into(), + } + } + + pub fn symbol(&self) -> &str { + &self.symbol + } +} + #[derive(Clone, Debug, Default, PartialEq, Eq)] -pub struct VerifierFieldVectorSourceSet { +pub(crate) struct VerifierFieldVectorValueSet { symbols: BTreeSet, } -impl VerifierFieldVectorSourceSet { - pub fn insert(&mut self, symbol: &str, _kind: VerifierFieldVectorSourceKind) { +impl VerifierFieldVectorValueSet { + pub(crate) fn insert(&mut self, symbol: &str, _kind: VerifierFieldVectorValueKind) { let _inserted = self.symbols.insert(symbol.to_owned()); } - pub fn extend<'a>( - &mut self, - symbols: impl IntoIterator, - kind: VerifierFieldVectorSourceKind, - ) { - for symbol in symbols { - self.insert(symbol, kind); + pub(crate) fn contains_ref(&self, value_ref: &VerifierFieldVectorValueRef) -> bool { + self.symbols.contains(value_ref.symbol()) + } + + pub(crate) fn source_set(&self) -> VerifierFieldVectorSourceSet { + let mut sources = VerifierFieldVectorSourceSet::default(); + for symbol in &self.symbols { + sources.insert( + symbol, + VerifierFieldVectorValueKind::IndexedEvalFamily.source_kind(), + ); } + sources + } +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct VerifierFieldVectorSourceSet { + symbols: BTreeSet, +} + +impl VerifierFieldVectorSourceSet { + pub fn insert(&mut self, symbol: &str, _kind: VerifierFieldVectorSourceKind) { + let _inserted = self.symbols.insert(symbol.to_owned()); } pub fn contains(&self, symbol: &str) -> bool { From 40caf869ef083dff07b2804f138c89b7c591b054 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 09:57:13 -0600 Subject: [PATCH 154/171] refactor(verifier): use typed vector value set Remove the derived field-vector source-set view and validate verifier field-vector scalar expressions directly against typed field-vector values. --- .../protocols/jolt/emit/rust/plan_tokens.rs | 9 +++-- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../src/protocols/jolt/emit/rust/stage6.rs | 2 +- .../bolt/src/protocols/jolt/verifier_plan.rs | 26 +++++++++---- .../src/protocols/jolt/verifier_values.rs | 39 ------------------- 5 files changed, 26 insertions(+), 52 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index 2c1983480b..f5f42b0bbf 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -8,7 +8,8 @@ use crate::protocols::jolt::rust_target_plan::{ TranscriptSqueezeKind, }; use crate::protocols::jolt::verifier_values::{ - VerifierFieldVectorSourceSet, VerifierPointSourceSet, VerifierScalarSourceSet, + VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointSourceSet, + VerifierScalarSourceSet, }; pub(super) fn role_program_step_kind_expr( @@ -160,7 +161,7 @@ pub(super) struct ScalarExprVerification<'a> { pub operand_names: &'a [String], pub operands: &'a [String], pub field_values: &'a VerifierScalarSourceSet, - pub field_vector_values: Option<&'a VerifierFieldVectorSourceSet>, + pub field_vector_values: Option<&'a VerifierFieldVectorValueSet>, pub point_values: Option<&'a VerifierPointSourceSet>, } @@ -194,7 +195,9 @@ pub(super) fn verify_scalar_expr_operands( }; verify_count("field vector expr operands", symbol, 1, operands.len())?; let operand = &operands[0]; - if !field_vector_values.contains(operand) { + if !field_vector_values + .contains_ref(&VerifierFieldVectorValueRef::new(operand.as_str())) + { return Err(EmitError::new(format!( "field vector expr @{symbol} references missing field vector @{operand}" ))); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 57d9fb9362..31b76b863c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -457,7 +457,7 @@ impl Stage5CpuProgram { self.cpu_field_value_sources() }; let field_vector_values = if self.role == Role::Verifier { - Some(self.verifier_plan()?.field_vector_value_sources()) + Some(self.verifier_plan()?.field_vector_values()) } else { None }; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 6bd716265e..4c895a5092 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -477,7 +477,7 @@ impl Stage6CpuProgram { self.cpu_field_value_sources() }; let field_vector_values = if self.role == Role::Verifier { - Some(self.verifier_plan()?.field_vector_value_sources()) + Some(self.verifier_plan()?.field_vector_values()) } else { None }; diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 1068f0edae..3a968fc532 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -30,9 +30,9 @@ use crate::protocols::jolt::verifier_value_rows::{ CpuFieldConstantPlan, CpuFieldExprPlan, CpuScalarExprPlan, }; use crate::protocols::jolt::verifier_values::{ - VerifierFieldVectorSourceSet, VerifierFieldVectorValueKind, VerifierFieldVectorValueSet, - VerifierPointSourceKind, VerifierPointSourceSet, VerifierScalarSourceSet, - VerifierScalarValueKind, VerifierScalarValuePlan, VerifierScalarValueSet, + VerifierFieldVectorValueKind, VerifierFieldVectorValueSet, VerifierPointSourceKind, + VerifierPointSourceSet, VerifierScalarSourceSet, VerifierScalarValueKind, + VerifierScalarValuePlan, VerifierScalarValueSet, }; #[derive(Clone, Debug, PartialEq, Eq)] @@ -524,10 +524,6 @@ impl VerifierStagePlan { values } - pub(crate) fn field_vector_value_sources(&self) -> VerifierFieldVectorSourceSet { - self.field_vector_values().source_set() - } - pub(crate) fn point_value_sources(&self) -> VerifierPointSourceSet { let mut values = VerifierPointSourceSet::default(); values.extend( @@ -2189,7 +2185,7 @@ mod tests { StructuredPolynomialPointSegment, }; use crate::protocols::jolt::verifier_values::{ - VerifierScalarValueKind, VerifierScalarValuePlan, + VerifierFieldVectorValueRef, VerifierScalarValueKind, VerifierScalarValuePlan, }; use super::{VerifierScalarExprPlan, VerifierStagePlan}; @@ -2240,6 +2236,20 @@ mod tests { Ok(()) } + #[test] + fn field_vector_values_classify_indexed_eval_families() { + let mut plan = VerifierStagePlan::default(); + plan.indexed_eval_families.push(IndexedEvalFamilyPlan { + symbol: "stage5.indexed.evals".to_owned(), + evals: vec!["stage5.eval.0".to_owned()], + }); + + let values = plan.field_vector_values(); + + assert!(values.contains_ref(&VerifierFieldVectorValueRef::new("stage5.indexed.evals"))); + assert!(!values.contains_ref(&VerifierFieldVectorValueRef::new("missing.family"))); + } + fn structured_polynomial_eval(symbol: &str) -> StructuredPolynomialEvalPlan { StructuredPolynomialEvalPlan { symbol: symbol.to_owned(), diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index a77a876f62..113f6bd20a 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -193,24 +193,11 @@ impl VerifierScalarSourceSet { } } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum VerifierFieldVectorSourceKind { - IndexedEvalFamily, -} - #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub(crate) enum VerifierFieldVectorValueKind { IndexedEvalFamily, } -impl VerifierFieldVectorValueKind { - fn source_kind(self) -> VerifierFieldVectorSourceKind { - match self { - Self::IndexedEvalFamily => VerifierFieldVectorSourceKind::IndexedEvalFamily, - } - } -} - #[derive(Clone, Debug, PartialEq, Eq)] pub struct VerifierFieldVectorValueRef { symbol: String, @@ -241,32 +228,6 @@ impl VerifierFieldVectorValueSet { pub(crate) fn contains_ref(&self, value_ref: &VerifierFieldVectorValueRef) -> bool { self.symbols.contains(value_ref.symbol()) } - - pub(crate) fn source_set(&self) -> VerifierFieldVectorSourceSet { - let mut sources = VerifierFieldVectorSourceSet::default(); - for symbol in &self.symbols { - sources.insert( - symbol, - VerifierFieldVectorValueKind::IndexedEvalFamily.source_kind(), - ); - } - sources - } -} - -#[derive(Clone, Debug, Default, PartialEq, Eq)] -pub struct VerifierFieldVectorSourceSet { - symbols: BTreeSet, -} - -impl VerifierFieldVectorSourceSet { - pub fn insert(&mut self, symbol: &str, _kind: VerifierFieldVectorSourceKind) { - let _inserted = self.symbols.insert(symbol.to_owned()); - } - - pub fn contains(&self, symbol: &str) -> bool { - self.symbols.contains(symbol) - } } #[derive(Clone, Copy, Debug, PartialEq, Eq)] From f45429c83e4c027841e3398847aece2874cf2057 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 10:14:44 -0600 Subject: [PATCH 155/171] refactor(verifier): type scalar expr operands Represent verifier scalar-expression operands as typed scalar, point, or field-vector refs and validate verifier stages against those typed plan rows. --- .../protocols/jolt/emit/rust/plan_tokens.rs | 178 +++++++++++++++++- .../src/protocols/jolt/emit/rust/stage3.rs | 41 ++-- .../src/protocols/jolt/emit/rust/stage4.rs | 41 ++-- .../src/protocols/jolt/emit/rust/stage5.rs | 46 ++--- .../src/protocols/jolt/emit/rust/stage6.rs | 46 ++--- .../src/protocols/jolt/emit/rust/stage7.rs | 41 ++-- .../bolt/src/protocols/jolt/verifier_plan.rs | 175 +++++++++++++++-- .../src/protocols/jolt/verifier_values.rs | 21 +++ 8 files changed, 453 insertions(+), 136 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index f5f42b0bbf..d62faa7d8f 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -7,9 +7,11 @@ use crate::protocols::jolt::rust_target_plan::{ ProgramStepKind, RustTargetPlanError, ScalarExprKind, SumcheckPointOrder, TranscriptSqueezeKind, }; +use crate::protocols::jolt::verifier_plan::{VerifierScalarExprOperand, VerifierScalarExprPlan}; +use crate::protocols::jolt::verifier_value_rows::CpuScalarExprPlan; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointSourceSet, - VerifierScalarSourceSet, + VerifierScalarSourceSet, VerifierScalarValueSet, }; pub(super) fn role_program_step_kind_expr( @@ -250,6 +252,180 @@ pub(super) fn verify_scalar_expr_operands( Ok(()) } +pub(super) struct VerifierScalarExprVerification<'a> { + pub stage: &'static str, + pub expr: &'a VerifierScalarExprPlan, + pub field_values: &'a VerifierScalarValueSet, + pub field_vector_values: Option<&'a VerifierFieldVectorValueSet>, + pub point_values: Option<&'a VerifierPointSourceSet>, +} + +pub(super) fn verify_verifier_scalar_expr_operands( + verification: VerifierScalarExprVerification<'_>, +) -> Result<(), EmitError> { + let VerifierScalarExprVerification { + stage, + expr, + field_values, + field_vector_values, + point_values, + } = verification; + match expr.kind { + ScalarExprKind::FieldVectorSum | ScalarExprKind::FieldVectorProduct => { + let Some(field_vector_values) = field_vector_values else { + return Err(EmitError::new(format!( + "{stage} scalar expr @{} uses field-vector formula without field-vector values", + expr.symbol + ))); + }; + verify_count( + "field vector expr operands", + &expr.symbol, + 1, + expr.operands.len(), + )?; + for operand in &expr.operands { + let VerifierScalarExprOperand::FieldVector(value_ref) = operand else { + return Err(EmitError::new(format!( + "{stage} scalar expr @{} expected field-vector operand @{}", + expr.symbol, + operand.symbol() + ))); + }; + if !field_vector_values.contains_ref(value_ref) { + return Err(EmitError::new(format!( + "field vector expr @{} references missing field vector @{}", + expr.symbol, + value_ref.symbol() + ))); + } + } + } + ScalarExprKind::PowerStridedWeightedSum { .. } => { + for operand in &expr.operands { + let VerifierScalarExprOperand::Field(value_ref) = operand else { + return Err(EmitError::new(format!( + "{stage} scalar expr @{} expected field operand @{}", + expr.symbol, + operand.symbol() + ))); + }; + if !field_values.contains_ref(value_ref) { + return Err(EmitError::new(format!( + "scalar expr @{} references missing field value @{}", + expr.symbol, + value_ref.symbol() + ))); + } + } + } + ScalarExprKind::StructuredPolynomial { .. } => { + verify_count( + "structured polynomial scalar expr operands", + &expr.symbol, + 2, + expr.operands.len(), + )?; + for operand in &expr.operands { + let VerifierScalarExprOperand::Point(value_ref) = operand else { + return Err(EmitError::new(format!( + "{stage} scalar expr @{} expected point operand @{}", + expr.symbol, + operand.symbol() + ))); + }; + if !point_values.is_some_and(|values| values.contains_ref(value_ref)) { + return Err(EmitError::new(format!( + "structured polynomial scalar expr @{} references missing point value @{}", + expr.symbol, + value_ref.symbol() + ))); + } + } + } + ScalarExprKind::PointElement { .. } => { + verify_count( + "point element scalar expr operands", + &expr.symbol, + 1, + expr.operands.len(), + )?; + let Some(point_values) = point_values else { + return Err(EmitError::new(format!( + "{stage} scalar expr @{} uses point element formula without point sources", + expr.symbol + ))); + }; + for operand in &expr.operands { + let VerifierScalarExprOperand::Point(value_ref) = operand else { + return Err(EmitError::new(format!( + "{stage} scalar expr @{} expected point operand @{}", + expr.symbol, + operand.symbol() + ))); + }; + if !point_values.contains_ref(value_ref) { + return Err(EmitError::new(format!( + "point element scalar expr @{} references missing point @{}", + expr.symbol, + value_ref.symbol() + ))); + } + } + } + } + Ok(()) +} + +pub(super) struct ScalarExprFlowVerification<'a> { + pub stage: &'static str, + pub cpu_exprs: &'a [CpuScalarExprPlan], + pub verifier_exprs: Option<&'a [VerifierScalarExprPlan]>, + pub field_values: &'a VerifierScalarSourceSet, + pub verifier_field_values: Option<&'a VerifierScalarValueSet>, + pub field_vector_values: Option<&'a VerifierFieldVectorValueSet>, + pub point_values: Option<&'a VerifierPointSourceSet>, +} + +pub(super) fn verify_scalar_expr_flow( + verification: ScalarExprFlowVerification<'_>, +) -> Result<(), EmitError> { + let ScalarExprFlowVerification { + stage, + cpu_exprs, + verifier_exprs, + field_values, + verifier_field_values, + field_vector_values, + point_values, + } = verification; + if let (Some(exprs), Some(field_values)) = (verifier_exprs, verifier_field_values) { + for expr in exprs { + verify_verifier_scalar_expr_operands(VerifierScalarExprVerification { + stage, + expr, + field_values, + field_vector_values, + point_values, + })?; + } + } else { + for expr in cpu_exprs { + verify_scalar_expr_operands(ScalarExprVerification { + stage, + symbol: &expr.symbol, + formula: &expr.formula, + operand_names: &expr.operand_names, + operands: &expr.operands, + field_values, + field_vector_values, + point_values, + })?; + } + } + Ok(()) +} + pub(super) fn role_relation_kind_expr( stage_type_prefix: &str, role: &Role, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 9555d67e80..9418fe3ae3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -351,16 +351,18 @@ impl Stage3CpuProgram { for constant in &self.field_constants { require_supported_symbol("field constant field", &constant.field, "bn254_fr")?; } - let field_values = if self.role == Role::Verifier { - self.verifier_plan()?.scalar_value_sources() - } else { - self.cpu_field_value_sources() - }; - let point_values = if self.role == Role::Verifier { - Some(self.verifier_plan()?.point_value_sources()) + let verifier_plan = if self.role == Role::Verifier { + Some(self.verifier_plan()?) } else { None }; + let verifier_scalar_values = verifier_plan.map(|plan| plan.scalar_values()); + let field_values = verifier_scalar_values.as_ref().map_or_else( + || self.cpu_field_value_sources(), + |values| values.source_set(), + ); + let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); + let point_values = verifier_plan.map(|plan| plan.point_value_sources()); for expr in &self.field_exprs { verify_count( "field expr operands", @@ -377,20 +379,17 @@ impl Stage3CpuProgram { } } } - for expr in &self.scalar_exprs { - super::plan_tokens::verify_scalar_expr_operands( - super::plan_tokens::ScalarExprVerification { - stage: "stage3", - symbol: &expr.symbol, - formula: &expr.formula, - operand_names: &expr.operand_names, - operands: &expr.operands, - field_values: &field_values, - field_vector_values: None, - point_values: point_values.as_ref(), - }, - )?; - } + super::plan_tokens::verify_scalar_expr_flow( + super::plan_tokens::ScalarExprFlowVerification { + stage: "stage3", + cpu_exprs: &self.scalar_exprs, + verifier_exprs: verifier_plan.map(|plan| plan.scalar_exprs.as_slice()), + field_values: &field_values, + verifier_field_values: verifier_scalar_values.as_ref(), + field_vector_values: field_vector_values.as_ref(), + point_values: point_values.as_ref(), + }, + )?; for claim in &self.claims { if !field_values.contains(&claim.claim_value) { return Err(EmitError::new(format!( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 102d41de59..0560a3d024 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -374,16 +374,18 @@ impl Stage4CpuProgram { for constant in &self.field_constants { require_supported_symbol("field constant field", &constant.field, "bn254_fr")?; } - let field_values = if self.role == Role::Verifier { - self.verifier_plan()?.scalar_value_sources() - } else { - self.cpu_field_value_sources() - }; - let point_values = if self.role == Role::Verifier { - Some(self.verifier_plan()?.point_value_sources()) + let verifier_plan = if self.role == Role::Verifier { + Some(self.verifier_plan()?) } else { None }; + let verifier_scalar_values = verifier_plan.map(|plan| plan.scalar_values()); + let field_values = verifier_scalar_values.as_ref().map_or_else( + || self.cpu_field_value_sources(), + |values| values.source_set(), + ); + let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); + let point_values = verifier_plan.map(|plan| plan.point_value_sources()); for expr in &self.field_exprs { verify_count( "field expr operands", @@ -400,20 +402,17 @@ impl Stage4CpuProgram { } } } - for expr in &self.scalar_exprs { - super::plan_tokens::verify_scalar_expr_operands( - super::plan_tokens::ScalarExprVerification { - stage: "stage4", - symbol: &expr.symbol, - formula: &expr.formula, - operand_names: &expr.operand_names, - operands: &expr.operands, - field_values: &field_values, - field_vector_values: None, - point_values: point_values.as_ref(), - }, - )?; - } + super::plan_tokens::verify_scalar_expr_flow( + super::plan_tokens::ScalarExprFlowVerification { + stage: "stage4", + cpu_exprs: &self.scalar_exprs, + verifier_exprs: verifier_plan.map(|plan| plan.scalar_exprs.as_slice()), + field_values: &field_values, + verifier_field_values: verifier_scalar_values.as_ref(), + field_vector_values: field_vector_values.as_ref(), + point_values: point_values.as_ref(), + }, + )?; for claim in &self.claims { if !field_values.contains(&claim.claim_value) { return Err(EmitError::new(format!( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 31b76b863c..be3b6ae6ce 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -451,21 +451,18 @@ impl Stage5CpuProgram { for constant in &self.field_constants { require_supported_symbol("field constant field", &constant.field, "bn254_fr")?; } - let field_values = if self.role == Role::Verifier { - self.verifier_plan()?.scalar_value_sources() - } else { - self.cpu_field_value_sources() - }; - let field_vector_values = if self.role == Role::Verifier { - Some(self.verifier_plan()?.field_vector_values()) - } else { - None - }; - let point_values = if self.role == Role::Verifier { - Some(self.verifier_plan()?.point_value_sources()) + let verifier_plan = if self.role == Role::Verifier { + Some(self.verifier_plan()?) } else { None }; + let verifier_scalar_values = verifier_plan.map(|plan| plan.scalar_values()); + let field_values = verifier_scalar_values.as_ref().map_or_else( + || self.cpu_field_value_sources(), + |values| values.source_set(), + ); + let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); + let point_values = verifier_plan.map(|plan| plan.point_value_sources()); for expr in &self.field_exprs { verify_count( "field expr operands", @@ -484,20 +481,17 @@ impl Stage5CpuProgram { } } } - for expr in &self.scalar_exprs { - super::plan_tokens::verify_scalar_expr_operands( - super::plan_tokens::ScalarExprVerification { - stage: "stage5", - symbol: &expr.symbol, - formula: &expr.formula, - operand_names: &expr.operand_names, - operands: &expr.operands, - field_values: &field_values, - field_vector_values: field_vector_values.as_ref(), - point_values: point_values.as_ref(), - }, - )?; - } + super::plan_tokens::verify_scalar_expr_flow( + super::plan_tokens::ScalarExprFlowVerification { + stage: "stage5", + cpu_exprs: &self.scalar_exprs, + verifier_exprs: verifier_plan.map(|plan| plan.scalar_exprs.as_slice()), + field_values: &field_values, + verifier_field_values: verifier_scalar_values.as_ref(), + field_vector_values: field_vector_values.as_ref(), + point_values: point_values.as_ref(), + }, + )?; for claim in &self.claims { if !field_values.contains(&claim.claim_value) { return Err(EmitError::new(format!( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 4c895a5092..18a21d5fcd 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -471,21 +471,18 @@ impl Stage6CpuProgram { for constant in &self.field_constants { require_supported_symbol("field constant field", &constant.field, "bn254_fr")?; } - let field_values = if self.role == Role::Verifier { - self.verifier_plan()?.scalar_value_sources() - } else { - self.cpu_field_value_sources() - }; - let field_vector_values = if self.role == Role::Verifier { - Some(self.verifier_plan()?.field_vector_values()) - } else { - None - }; - let point_values = if self.role == Role::Verifier { - Some(self.verifier_plan()?.point_value_sources()) + let verifier_plan = if self.role == Role::Verifier { + Some(self.verifier_plan()?) } else { None }; + let verifier_scalar_values = verifier_plan.map(|plan| plan.scalar_values()); + let field_values = verifier_scalar_values.as_ref().map_or_else( + || self.cpu_field_value_sources(), + |values| values.source_set(), + ); + let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); + let point_values = verifier_plan.map(|plan| plan.point_value_sources()); for expr in &self.field_exprs { verify_count( "field expr operands", @@ -504,20 +501,17 @@ impl Stage6CpuProgram { } } } - for expr in &self.scalar_exprs { - super::plan_tokens::verify_scalar_expr_operands( - super::plan_tokens::ScalarExprVerification { - stage: "stage6", - symbol: &expr.symbol, - formula: &expr.formula, - operand_names: &expr.operand_names, - operands: &expr.operands, - field_values: &field_values, - field_vector_values: field_vector_values.as_ref(), - point_values: point_values.as_ref(), - }, - )?; - } + super::plan_tokens::verify_scalar_expr_flow( + super::plan_tokens::ScalarExprFlowVerification { + stage: "stage6", + cpu_exprs: &self.scalar_exprs, + verifier_exprs: verifier_plan.map(|plan| plan.scalar_exprs.as_slice()), + field_values: &field_values, + verifier_field_values: verifier_scalar_values.as_ref(), + field_vector_values: field_vector_values.as_ref(), + point_values: point_values.as_ref(), + }, + )?; for claim in &self.claims { if !field_values.contains(&claim.claim_value) { return Err(EmitError::new(format!( diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index e2bcc41e7d..e38b162b37 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -577,16 +577,18 @@ impl Stage7CpuProgram { for constant in &self.field_constants { require_supported_symbol("field constant field", &constant.field, "bn254_fr")?; } - let field_values = if self.role == Role::Verifier { - self.verifier_plan()?.scalar_value_sources() - } else { - self.cpu_field_value_sources() - }; - let point_values = if self.role == Role::Verifier { - Some(self.verifier_plan()?.point_value_sources()) + let verifier_plan = if self.role == Role::Verifier { + Some(self.verifier_plan()?) } else { None }; + let verifier_scalar_values = verifier_plan.map(|plan| plan.scalar_values()); + let field_values = verifier_scalar_values.as_ref().map_or_else( + || self.cpu_field_value_sources(), + |values| values.source_set(), + ); + let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); + let point_values = verifier_plan.map(|plan| plan.point_value_sources()); for expr in &self.field_exprs { verify_count( "field expr operands", @@ -603,20 +605,17 @@ impl Stage7CpuProgram { } } } - for expr in &self.scalar_exprs { - super::plan_tokens::verify_scalar_expr_operands( - super::plan_tokens::ScalarExprVerification { - stage: "stage7", - symbol: &expr.symbol, - formula: &expr.formula, - operand_names: &expr.operand_names, - operands: &expr.operands, - field_values: &field_values, - field_vector_values: None, - point_values: point_values.as_ref(), - }, - )?; - } + super::plan_tokens::verify_scalar_expr_flow( + super::plan_tokens::ScalarExprFlowVerification { + stage: "stage7", + cpu_exprs: &self.scalar_exprs, + verifier_exprs: verifier_plan.map(|plan| plan.scalar_exprs.as_slice()), + field_values: &field_values, + verifier_field_values: verifier_scalar_values.as_ref(), + field_vector_values: field_vector_values.as_ref(), + point_values: point_values.as_ref(), + }, + )?; for claim in &self.claims { if !field_values.contains(&claim.claim_value) { return Err(EmitError::new(format!( diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 3a968fc532..2a96655c1a 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -30,9 +30,10 @@ use crate::protocols::jolt::verifier_value_rows::{ CpuFieldConstantPlan, CpuFieldExprPlan, CpuScalarExprPlan, }; use crate::protocols::jolt::verifier_values::{ - VerifierFieldVectorValueKind, VerifierFieldVectorValueSet, VerifierPointSourceKind, - VerifierPointSourceSet, VerifierScalarSourceSet, VerifierScalarValueKind, - VerifierScalarValuePlan, VerifierScalarValueSet, + VerifierFieldVectorValueKind, VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, + VerifierPointSourceKind, VerifierPointSourceSet, VerifierPointValueRef, + VerifierScalarSourceSet, VerifierScalarValueKind, VerifierScalarValuePlan, + VerifierScalarValueRef, VerifierScalarValueSet, }; #[derive(Clone, Debug, PartialEq, Eq)] @@ -156,7 +157,24 @@ impl VerifierFieldExprPlan { pub(crate) struct VerifierScalarExprPlan { pub(crate) symbol: String, pub(crate) kind: ScalarExprKind, - pub(crate) operands: Vec, + pub(crate) operands: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) enum VerifierScalarExprOperand { + Field(VerifierScalarValueRef), + FieldVector(VerifierFieldVectorValueRef), + Point(VerifierPointValueRef), +} + +impl VerifierScalarExprOperand { + pub(crate) fn symbol(&self) -> &str { + match self { + Self::Field(value_ref) => value_ref.symbol(), + Self::FieldVector(value_ref) => value_ref.symbol(), + Self::Point(value_ref) => value_ref.symbol(), + } + } } impl VerifierScalarExprPlan { @@ -165,14 +183,64 @@ impl VerifierScalarExprPlan { formula: &str, operands: &[String], ) -> Result { + let kind = ScalarExprKind::from_cpu_attr(formula).map_err(plan_error)?; Ok(Self { symbol: symbol.to_owned(), - kind: ScalarExprKind::from_cpu_attr(formula).map_err(plan_error)?, - operands: operands.to_vec(), + operands: scalar_expr_operands(symbol, &kind, operands)?, + kind, }) } } +fn scalar_expr_operands( + symbol: &str, + kind: &ScalarExprKind, + operands: &[String], +) -> Result, EmitError> { + match kind { + ScalarExprKind::FieldVectorSum | ScalarExprKind::FieldVectorProduct => { + verify_plan_operand_count("field-vector scalar expr", symbol, 1, operands.len())?; + Ok(operands + .iter() + .map(|operand| { + VerifierScalarExprOperand::FieldVector(VerifierFieldVectorValueRef::new( + operand.as_str(), + )) + }) + .collect()) + } + ScalarExprKind::PowerStridedWeightedSum { .. } => Ok(operands + .iter() + .map(|operand| { + VerifierScalarExprOperand::Field(VerifierScalarValueRef::new(operand.as_str())) + }) + .collect()), + ScalarExprKind::StructuredPolynomial { .. } => { + verify_plan_operand_count( + "structured polynomial scalar expr", + symbol, + 2, + operands.len(), + )?; + Ok(operands + .iter() + .map(|operand| { + VerifierScalarExprOperand::Point(VerifierPointValueRef::new(operand.as_str())) + }) + .collect()) + } + ScalarExprKind::PointElement { .. } => { + verify_plan_operand_count("point element scalar expr", symbol, 1, operands.len())?; + Ok(operands + .iter() + .map(|operand| { + VerifierScalarExprOperand::Point(VerifierPointValueRef::new(operand.as_str())) + }) + .collect()) + } + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct VerifierSumcheckEvalPlan { pub(crate) symbol: String, @@ -1782,7 +1850,7 @@ pub(crate) fn emit_scalar_expr_constants( " {stage_type_prefix}ScalarExprPlan {{ symbol: {}, kind: {}, operands: {} }},", rust_str(&expr.symbol), scalar_expr_kind_expr(stage_type_prefix, &expr.kind), - rust_str_slice_expr(&expr.operands), + scalar_expr_operand_slice_expr(&expr.operands), ) }) .collect::>() @@ -1840,7 +1908,7 @@ pub(crate) fn emit_scalar_expr_constants_chunked( "{helper_name}({}, {}, {})", rust_str(&expr.symbol), scalar_expr_kind_expr(stage_type_prefix, &expr.kind), - rust_str_slice_expr(&expr.operands) + scalar_expr_operand_slice_expr(&expr.operands) ) }) .collect::>() @@ -1854,6 +1922,18 @@ pub(crate) fn emit_scalar_expr_constants_chunked( ) } +fn scalar_expr_operand_slice_expr(operands: &[VerifierScalarExprOperand]) -> String { + if operands.is_empty() { + return "&[]".to_owned(); + } + let values = operands + .iter() + .map(|operand| rust_str(operand.symbol())) + .collect::>() + .join(", "); + format!("&[{values}]") +} + pub(crate) fn emit_sumcheck_claim_constants( stage_type_prefix: &str, const_prefix: &str, @@ -2167,13 +2247,27 @@ fn rust_str(value: &str) -> String { format!("{value:?}") } +fn verify_plan_operand_count( + kind: &str, + symbol: &str, + expected: usize, + actual: usize, +) -> Result<(), EmitError> { + if expected == actual { + Ok(()) + } else { + Err(EmitError::new(format!( + "{kind} @{symbol} operand count mismatch: expected {expected}, got {actual}" + ))) + } +} + fn plan_error(error: RustTargetPlanError) -> EmitError { EmitError::new(error.to_string()) } #[cfg(test)] mod tests { - use crate::protocols::jolt::rust_target_plan::ScalarExprKind; use crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionReadRafEmitPlan; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_local_scalars::{ @@ -2188,26 +2282,29 @@ mod tests { VerifierFieldVectorValueRef, VerifierScalarValueKind, VerifierScalarValuePlan, }; - use super::{VerifierScalarExprPlan, VerifierStagePlan}; + use super::{VerifierScalarExprOperand, VerifierScalarExprPlan, VerifierStagePlan}; #[test] fn scalar_value_plans_classify_structured_evals_and_local_scalars() -> Result<(), String> { let mut plan = VerifierStagePlan::default(); plan.relation_output_values .push(structured_polynomial_eval("stage5.output.eq")); - plan.scalar_exprs.push(VerifierScalarExprPlan { - symbol: "stage5.output.eq".to_owned(), - kind: ScalarExprKind::from_cpu_attr( + plan.scalar_exprs.push( + VerifierScalarExprPlan::from_cpu( + "stage5.output.eq", "poly.structured_eval:eq:full:full:as_is:full:full:as_is", + &["point.x".to_owned(), "point.y".to_owned()], ) .map_err(|error| error.to_string())?, - operands: vec!["point.x".to_owned(), "point.y".to_owned()], - }); - plan.scalar_exprs.push(VerifierScalarExprPlan { - symbol: "stage5.output.sum".to_owned(), - kind: ScalarExprKind::FieldVectorSum, - operands: vec!["field.vector".to_owned()], - }); + ); + plan.scalar_exprs.push( + VerifierScalarExprPlan::from_cpu( + "stage5.output.sum", + "field_vector.sum", + &["field.vector".to_owned()], + ) + .map_err(|error| error.to_string())?, + ); plan.relation_local_inputs .add_stage5_instruction_read_raf(stage5_local_input_plan()) .map_err(|error| error.to_string())?; @@ -2236,6 +2333,44 @@ mod tests { Ok(()) } + #[test] + fn scalar_expr_plan_types_operands_by_formula() -> Result<(), String> { + let field_expr = VerifierScalarExprPlan::from_cpu( + "field.expr", + "field.power_strided_weighted_sum:2:1:0:1:2", + &["field.value".to_owned()], + ) + .map_err(|error| error.to_string())?; + assert!(matches!( + &field_expr.operands[..], + [VerifierScalarExprOperand::Field(value_ref)] if value_ref.symbol() == "field.value" + )); + + let vector_expr = VerifierScalarExprPlan::from_cpu( + "vector.expr", + "field_vector.product", + &["vector.value".to_owned()], + ) + .map_err(|error| error.to_string())?; + assert!(matches!( + &vector_expr.operands[..], + [VerifierScalarExprOperand::FieldVector(value_ref)] if value_ref.symbol() == "vector.value" + )); + + let point_expr = VerifierScalarExprPlan::from_cpu( + "point.expr", + "point.element:0", + &["point.value".to_owned()], + ) + .map_err(|error| error.to_string())?; + assert!(matches!( + &point_expr.operands[..], + [VerifierScalarExprOperand::Point(value_ref)] if value_ref.symbol() == "point.value" + )); + + Ok(()) + } + #[test] fn field_vector_values_classify_indexed_eval_families() { let mut plan = VerifierStagePlan::default(); diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 113f6bd20a..9831051366 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -237,6 +237,23 @@ pub enum VerifierPointSourceKind { PointExpr, } +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct VerifierPointValueRef { + symbol: String, +} + +impl VerifierPointValueRef { + pub fn new(symbol: impl Into) -> Self { + Self { + symbol: symbol.into(), + } + } + + pub fn symbol(&self) -> &str { + &self.symbol + } +} + #[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct VerifierPointSourceSet { symbols: BTreeMap, @@ -276,6 +293,10 @@ impl VerifierPointSourceSet { self.symbols.contains_key(symbol) } + pub(crate) fn contains_ref(&self, value_ref: &VerifierPointValueRef) -> bool { + self.symbols.contains_key(value_ref.symbol()) + } + pub(crate) fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { let Some(conflict) = self.conflicts.first() else { return Ok(()); From 715e57581f91069ca7196a399bdfe9fc2bfb1f9d Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 10:21:46 -0600 Subject: [PATCH 156/171] refactor(verifier): type field expr operands Represent verifier field-expression operands as typed scalar refs and validate verifier stages against typed field-expression plan rows. --- .../protocols/jolt/emit/rust/plan_tokens.rs | 57 ++++++++++++++++++- .../src/protocols/jolt/emit/rust/stage3.rs | 24 +++----- .../src/protocols/jolt/emit/rust/stage4.rs | 24 +++----- .../src/protocols/jolt/emit/rust/stage5.rs | 28 +++------ .../src/protocols/jolt/emit/rust/stage6.rs | 28 +++------ .../src/protocols/jolt/emit/rust/stage7.rs | 24 +++----- .../bolt/src/protocols/jolt/verifier_plan.rs | 41 +++++++++++-- 7 files changed, 133 insertions(+), 93 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index d62faa7d8f..1c358e4d16 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -7,8 +7,10 @@ use crate::protocols::jolt::rust_target_plan::{ ProgramStepKind, RustTargetPlanError, ScalarExprKind, SumcheckPointOrder, TranscriptSqueezeKind, }; -use crate::protocols::jolt::verifier_plan::{VerifierScalarExprOperand, VerifierScalarExprPlan}; -use crate::protocols::jolt::verifier_value_rows::CpuScalarExprPlan; +use crate::protocols::jolt::verifier_plan::{ + VerifierFieldExprPlan, VerifierScalarExprOperand, VerifierScalarExprPlan, +}; +use crate::protocols::jolt::verifier_value_rows::{CpuFieldExprPlan, CpuScalarExprPlan}; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointSourceSet, VerifierScalarSourceSet, VerifierScalarValueSet, @@ -156,6 +158,57 @@ pub(super) fn symbols<'a>(values: impl Iterator) -> BTreeSet< values.cloned().collect() } +pub(super) struct FieldExprFlowVerification<'a> { + pub cpu_exprs: &'a [CpuFieldExprPlan], + pub verifier_exprs: Option<&'a [VerifierFieldExprPlan]>, + pub field_values: &'a VerifierScalarSourceSet, + pub verifier_field_values: Option<&'a VerifierScalarValueSet>, +} + +pub(super) fn verify_field_expr_flow( + verification: FieldExprFlowVerification<'_>, +) -> Result<(), EmitError> { + let FieldExprFlowVerification { + cpu_exprs, + verifier_exprs, + field_values, + verifier_field_values, + } = verification; + if let (Some(exprs), Some(field_values)) = (verifier_exprs, verifier_field_values) { + for expr in exprs { + for operand in &expr.operands { + if !field_values.contains_ref(operand) { + return Err(EmitError::new(format!( + "field expr @{} references missing field value @{}", + expr.symbol, + operand.symbol() + ))); + } + } + } + } else { + for expr in cpu_exprs { + verify_count( + "field expr operands", + &expr.symbol, + expr.operand_names.len(), + expr.operands.len(), + )?; + let _kind = FieldExprKind::from_cpu_attr(&expr.formula) + .map_err(|error| EmitError::new(error.to_string()))?; + for operand in &expr.operands { + if !field_values.contains(operand) { + return Err(EmitError::new(format!( + "field expr @{} references missing field value @{operand}", + expr.symbol + ))); + } + } + } + } + Ok(()) +} + pub(super) struct ScalarExprVerification<'a> { pub stage: &'static str, pub symbol: &'a str, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 9418fe3ae3..c94b24087c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -363,22 +363,14 @@ impl Stage3CpuProgram { ); let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); let point_values = verifier_plan.map(|plan| plan.point_value_sources()); - for expr in &self.field_exprs { - verify_count( - "field expr operands", - &expr.symbol, - expr.operand_names.len(), - expr.operands.len(), - )?; - for operand in &expr.operands { - if !field_values.contains(operand) { - return Err(EmitError::new(format!( - "field expr @{} references missing field value @{operand}", - expr.symbol - ))); - } - } - } + super::plan_tokens::verify_field_expr_flow( + super::plan_tokens::FieldExprFlowVerification { + cpu_exprs: &self.field_exprs, + verifier_exprs: verifier_plan.map(|plan| plan.field_exprs.as_slice()), + field_values: &field_values, + verifier_field_values: verifier_scalar_values.as_ref(), + }, + )?; super::plan_tokens::verify_scalar_expr_flow( super::plan_tokens::ScalarExprFlowVerification { stage: "stage3", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 0560a3d024..7403537a36 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -386,22 +386,14 @@ impl Stage4CpuProgram { ); let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); let point_values = verifier_plan.map(|plan| plan.point_value_sources()); - for expr in &self.field_exprs { - verify_count( - "field expr operands", - &expr.symbol, - expr.operand_names.len(), - expr.operands.len(), - )?; - for operand in &expr.operands { - if !field_values.contains(operand) { - return Err(EmitError::new(format!( - "field expr @{} references missing field value @{operand}", - expr.symbol - ))); - } - } - } + super::plan_tokens::verify_field_expr_flow( + super::plan_tokens::FieldExprFlowVerification { + cpu_exprs: &self.field_exprs, + verifier_exprs: verifier_plan.map(|plan| plan.field_exprs.as_slice()), + field_values: &field_values, + verifier_field_values: verifier_scalar_values.as_ref(), + }, + )?; super::plan_tokens::verify_scalar_expr_flow( super::plan_tokens::ScalarExprFlowVerification { stage: "stage4", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index be3b6ae6ce..b98e7b0111 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -13,7 +13,7 @@ use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr, }; -use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; +use crate::protocols::jolt::rust_target_plan::ScalarExprKind; use crate::protocols::jolt::stage5_instruction_read_raf_plan::{ Stage5InstructionReadRafEmitPlan, Stage5InstructionReadRafOutputFieldExprPlan, }; @@ -463,24 +463,14 @@ impl Stage5CpuProgram { ); let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); let point_values = verifier_plan.map(|plan| plan.point_value_sources()); - for expr in &self.field_exprs { - verify_count( - "field expr operands", - &expr.symbol, - expr.operand_names.len(), - expr.operands.len(), - )?; - let _kind = FieldExprKind::from_cpu_attr(&expr.formula) - .map_err(|error| EmitError::new(error.to_string()))?; - for operand in &expr.operands { - if !field_values.contains(operand) { - return Err(EmitError::new(format!( - "field expr @{} references missing field value @{operand}", - expr.symbol - ))); - } - } - } + super::plan_tokens::verify_field_expr_flow( + super::plan_tokens::FieldExprFlowVerification { + cpu_exprs: &self.field_exprs, + verifier_exprs: verifier_plan.map(|plan| plan.field_exprs.as_slice()), + field_values: &field_values, + verifier_field_values: verifier_scalar_values.as_ref(), + }, + )?; super::plan_tokens::verify_scalar_expr_flow( super::plan_tokens::ScalarExprFlowVerification { stage: "stage5", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 18a21d5fcd..d481fe6ffa 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -13,7 +13,7 @@ use crate::ir::{BoltModule, Cpu, Role}; use crate::protocols::jolt::cpu_attrs::{ operand_symbol, operand_symbols, operation_name, string_attr, symbol_array_attr, symbol_attr, }; -use crate::protocols::jolt::rust_target_plan::{FieldExprKind, ScalarExprKind}; +use crate::protocols::jolt::rust_target_plan::ScalarExprKind; use crate::protocols::jolt::stage6_bytecode_read_raf_plan::Stage6BytecodeReadRafEmitPlan; use crate::protocols::jolt::verifier_eval_families::{self, IndexedEvalFamilyPlan}; use crate::protocols::jolt::verifier_opening_rows; @@ -483,24 +483,14 @@ impl Stage6CpuProgram { ); let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); let point_values = verifier_plan.map(|plan| plan.point_value_sources()); - for expr in &self.field_exprs { - verify_count( - "field expr operands", - &expr.symbol, - expr.operand_names.len(), - expr.operands.len(), - )?; - let _kind = FieldExprKind::from_cpu_attr(&expr.formula) - .map_err(|error| EmitError::new(error.to_string()))?; - for operand in &expr.operands { - if !field_values.contains(operand) { - return Err(EmitError::new(format!( - "field expr @{} references missing field value @{operand}", - expr.symbol - ))); - } - } - } + super::plan_tokens::verify_field_expr_flow( + super::plan_tokens::FieldExprFlowVerification { + cpu_exprs: &self.field_exprs, + verifier_exprs: verifier_plan.map(|plan| plan.field_exprs.as_slice()), + field_values: &field_values, + verifier_field_values: verifier_scalar_values.as_ref(), + }, + )?; super::plan_tokens::verify_scalar_expr_flow( super::plan_tokens::ScalarExprFlowVerification { stage: "stage6", diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index e38b162b37..4fb121dff7 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -589,22 +589,14 @@ impl Stage7CpuProgram { ); let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); let point_values = verifier_plan.map(|plan| plan.point_value_sources()); - for expr in &self.field_exprs { - verify_count( - "field expr operands", - &expr.symbol, - expr.operand_names.len(), - expr.operands.len(), - )?; - for operand in &expr.operands { - if !field_values.contains(operand) { - return Err(EmitError::new(format!( - "field expr @{} references missing field value @{operand}", - expr.symbol - ))); - } - } - } + super::plan_tokens::verify_field_expr_flow( + super::plan_tokens::FieldExprFlowVerification { + cpu_exprs: &self.field_exprs, + verifier_exprs: verifier_plan.map(|plan| plan.field_exprs.as_slice()), + field_values: &field_values, + verifier_field_values: verifier_scalar_values.as_ref(), + }, + )?; super::plan_tokens::verify_scalar_expr_flow( super::plan_tokens::ScalarExprFlowVerification { stage: "stage7", diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 2a96655c1a..240e1a945b 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -136,7 +136,7 @@ pub(crate) struct VerifierFieldConstantPlan { pub(crate) struct VerifierFieldExprPlan { pub(crate) symbol: String, pub(crate) kind: FieldExprKind, - pub(crate) operands: Vec, + pub(crate) operands: Vec, } impl VerifierFieldExprPlan { @@ -148,7 +148,10 @@ impl VerifierFieldExprPlan { Ok(Self { symbol: symbol.to_owned(), kind: FieldExprKind::from_cpu_attr(formula).map_err(plan_error)?, - operands: operands.to_vec(), + operands: operands + .iter() + .map(|operand| VerifierScalarValueRef::new(operand.as_str())) + .collect(), }) } } @@ -1828,7 +1831,7 @@ pub(crate) fn emit_field_expr_constants( " {stage_type_prefix}FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", rust_str(&expr.symbol), field_expr_kind_expr(stage_type_prefix, &expr.kind), - rust_str_slice_expr(&expr.operands), + field_expr_operand_slice_expr(&expr.operands), ) }) .collect::>() @@ -1877,7 +1880,7 @@ pub(crate) fn emit_field_expr_constants_chunked( "{helper_name}({}, {}, {})", rust_str(&expr.symbol), field_expr_kind_expr(stage_type_prefix, &expr.kind), - rust_str_slice_expr(&expr.operands) + field_expr_operand_slice_expr(&expr.operands) ) }) .collect::>() @@ -1891,6 +1894,18 @@ pub(crate) fn emit_field_expr_constants_chunked( ) } +fn field_expr_operand_slice_expr(operands: &[VerifierScalarValueRef]) -> String { + if operands.is_empty() { + return "&[]".to_owned(); + } + let values = operands + .iter() + .map(|operand| rust_str(operand.symbol())) + .collect::>() + .join(", "); + format!("&[{values}]") +} + pub(crate) fn emit_scalar_expr_constants_chunked( stage_type_prefix: &str, const_prefix: &str, @@ -2282,7 +2297,9 @@ mod tests { VerifierFieldVectorValueRef, VerifierScalarValueKind, VerifierScalarValuePlan, }; - use super::{VerifierScalarExprOperand, VerifierScalarExprPlan, VerifierStagePlan}; + use super::{ + VerifierFieldExprPlan, VerifierScalarExprOperand, VerifierScalarExprPlan, VerifierStagePlan, + }; #[test] fn scalar_value_plans_classify_structured_evals_and_local_scalars() -> Result<(), String> { @@ -2333,6 +2350,20 @@ mod tests { Ok(()) } + #[test] + fn field_expr_plan_types_scalar_operands() -> Result<(), String> { + let expr = VerifierFieldExprPlan::from_cpu( + "field.expr", + "field.add", + &["left.value".to_owned(), "right.value".to_owned()], + ) + .map_err(|error| error.to_string())?; + + assert_eq!(expr.operands[0].symbol(), "left.value"); + assert_eq!(expr.operands[1].symbol(), "right.value"); + Ok(()) + } + #[test] fn scalar_expr_plan_types_operands_by_formula() -> Result<(), String> { let field_expr = VerifierScalarExprPlan::from_cpu( From eb687e4ccb7df30261c0e6f6f0e8a5d7f0781a1f Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 10:34:01 -0600 Subject: [PATCH 157/171] refactor(verifier): type point value set Represent verifier point values as typed plan data and validate verifier scalar-expression point operands against point value refs. --- .../protocols/jolt/emit/rust/plan_tokens.rs | 11 +++- .../src/protocols/jolt/emit/rust/stage3.rs | 6 +- .../src/protocols/jolt/emit/rust/stage4.rs | 6 +- .../src/protocols/jolt/emit/rust/stage5.rs | 6 +- .../src/protocols/jolt/emit/rust/stage6.rs | 6 +- .../src/protocols/jolt/emit/rust/stage7.rs | 6 +- .../bolt/src/protocols/jolt/verifier_plan.rs | 57 ++++++++++------ .../src/protocols/jolt/verifier_values.rs | 66 +++++++++++++++++-- 8 files changed, 133 insertions(+), 31 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index 1c358e4d16..b20f3a4896 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -13,7 +13,7 @@ use crate::protocols::jolt::verifier_plan::{ use crate::protocols::jolt::verifier_value_rows::{CpuFieldExprPlan, CpuScalarExprPlan}; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointSourceSet, - VerifierScalarSourceSet, VerifierScalarValueSet, + VerifierPointValueSet, VerifierScalarSourceSet, VerifierScalarValueSet, }; pub(super) fn role_program_step_kind_expr( @@ -310,7 +310,7 @@ pub(super) struct VerifierScalarExprVerification<'a> { pub expr: &'a VerifierScalarExprPlan, pub field_values: &'a VerifierScalarValueSet, pub field_vector_values: Option<&'a VerifierFieldVectorValueSet>, - pub point_values: Option<&'a VerifierPointSourceSet>, + pub point_values: Option<&'a VerifierPointValueSet>, } pub(super) fn verify_verifier_scalar_expr_operands( @@ -438,6 +438,7 @@ pub(super) struct ScalarExprFlowVerification<'a> { pub verifier_field_values: Option<&'a VerifierScalarValueSet>, pub field_vector_values: Option<&'a VerifierFieldVectorValueSet>, pub point_values: Option<&'a VerifierPointSourceSet>, + pub verifier_point_values: Option<&'a VerifierPointValueSet>, } pub(super) fn verify_scalar_expr_flow( @@ -451,15 +452,19 @@ pub(super) fn verify_scalar_expr_flow( verifier_field_values, field_vector_values, point_values, + verifier_point_values, } = verification; if let (Some(exprs), Some(field_values)) = (verifier_exprs, verifier_field_values) { + if let Some(point_values) = verifier_point_values { + point_values.verify_no_conflicts(stage)?; + } for expr in exprs { verify_verifier_scalar_expr_operands(VerifierScalarExprVerification { stage, expr, field_values, field_vector_values, - point_values, + point_values: verifier_point_values, })?; } } else { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index c94b24087c..82002522dd 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -362,7 +362,10 @@ impl Stage3CpuProgram { |values| values.source_set(), ); let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); - let point_values = verifier_plan.map(|plan| plan.point_value_sources()); + let verifier_point_values = verifier_plan.map(|plan| plan.point_values()); + let point_values = verifier_point_values + .as_ref() + .map(|values| values.source_set()); super::plan_tokens::verify_field_expr_flow( super::plan_tokens::FieldExprFlowVerification { cpu_exprs: &self.field_exprs, @@ -380,6 +383,7 @@ impl Stage3CpuProgram { verifier_field_values: verifier_scalar_values.as_ref(), field_vector_values: field_vector_values.as_ref(), point_values: point_values.as_ref(), + verifier_point_values: verifier_point_values.as_ref(), }, )?; for claim in &self.claims { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 7403537a36..480de8f47a 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -385,7 +385,10 @@ impl Stage4CpuProgram { |values| values.source_set(), ); let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); - let point_values = verifier_plan.map(|plan| plan.point_value_sources()); + let verifier_point_values = verifier_plan.map(|plan| plan.point_values()); + let point_values = verifier_point_values + .as_ref() + .map(|values| values.source_set()); super::plan_tokens::verify_field_expr_flow( super::plan_tokens::FieldExprFlowVerification { cpu_exprs: &self.field_exprs, @@ -403,6 +406,7 @@ impl Stage4CpuProgram { verifier_field_values: verifier_scalar_values.as_ref(), field_vector_values: field_vector_values.as_ref(), point_values: point_values.as_ref(), + verifier_point_values: verifier_point_values.as_ref(), }, )?; for claim in &self.claims { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index b98e7b0111..14c2c1e8e4 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -462,7 +462,10 @@ impl Stage5CpuProgram { |values| values.source_set(), ); let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); - let point_values = verifier_plan.map(|plan| plan.point_value_sources()); + let verifier_point_values = verifier_plan.map(|plan| plan.point_values()); + let point_values = verifier_point_values + .as_ref() + .map(|values| values.source_set()); super::plan_tokens::verify_field_expr_flow( super::plan_tokens::FieldExprFlowVerification { cpu_exprs: &self.field_exprs, @@ -480,6 +483,7 @@ impl Stage5CpuProgram { verifier_field_values: verifier_scalar_values.as_ref(), field_vector_values: field_vector_values.as_ref(), point_values: point_values.as_ref(), + verifier_point_values: verifier_point_values.as_ref(), }, )?; for claim in &self.claims { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index d481fe6ffa..9fe69342e4 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -482,7 +482,10 @@ impl Stage6CpuProgram { |values| values.source_set(), ); let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); - let point_values = verifier_plan.map(|plan| plan.point_value_sources()); + let verifier_point_values = verifier_plan.map(|plan| plan.point_values()); + let point_values = verifier_point_values + .as_ref() + .map(|values| values.source_set()); super::plan_tokens::verify_field_expr_flow( super::plan_tokens::FieldExprFlowVerification { cpu_exprs: &self.field_exprs, @@ -500,6 +503,7 @@ impl Stage6CpuProgram { verifier_field_values: verifier_scalar_values.as_ref(), field_vector_values: field_vector_values.as_ref(), point_values: point_values.as_ref(), + verifier_point_values: verifier_point_values.as_ref(), }, )?; for claim in &self.claims { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 4fb121dff7..79a76b973c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -588,7 +588,10 @@ impl Stage7CpuProgram { |values| values.source_set(), ); let field_vector_values = verifier_plan.map(|plan| plan.field_vector_values()); - let point_values = verifier_plan.map(|plan| plan.point_value_sources()); + let verifier_point_values = verifier_plan.map(|plan| plan.point_values()); + let point_values = verifier_point_values + .as_ref() + .map(|values| values.source_set()); super::plan_tokens::verify_field_expr_flow( super::plan_tokens::FieldExprFlowVerification { cpu_exprs: &self.field_exprs, @@ -606,6 +609,7 @@ impl Stage7CpuProgram { verifier_field_values: verifier_scalar_values.as_ref(), field_vector_values: field_vector_values.as_ref(), point_values: point_values.as_ref(), + verifier_point_values: verifier_point_values.as_ref(), }, )?; for claim in &self.claims { diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 240e1a945b..08a3f2005f 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -31,7 +31,7 @@ use crate::protocols::jolt::verifier_value_rows::{ }; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorValueKind, VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, - VerifierPointSourceKind, VerifierPointSourceSet, VerifierPointValueRef, + VerifierPointSourceSet, VerifierPointValueKind, VerifierPointValueRef, VerifierPointValueSet, VerifierScalarSourceSet, VerifierScalarValueKind, VerifierScalarValuePlan, VerifierScalarValueRef, VerifierScalarValueSet, }; @@ -595,25 +595,24 @@ impl VerifierStagePlan { values } - pub(crate) fn point_value_sources(&self) -> VerifierPointSourceSet { - let mut values = VerifierPointSourceSet::default(); - values.extend( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - VerifierPointSourceKind::SumcheckInstance, - ); - values.extend( - self.opening_inputs.iter().map(|input| &input.symbol), - VerifierPointSourceKind::OpeningInput, - ); - values.extend( - self.point_exprs.iter().map(|expr| &expr.symbol), - VerifierPointSourceKind::PointExpr, - ); + pub(crate) fn point_values(&self) -> VerifierPointValueSet { + let mut values = VerifierPointValueSet::default(); + for instance in &self.instance_results { + values.insert(&instance.symbol, VerifierPointValueKind::SumcheckInstance); + } + for input in &self.opening_inputs { + values.insert(&input.symbol, VerifierPointValueKind::OpeningInput); + } + for expr in &self.point_exprs { + values.insert(&expr.symbol, VerifierPointValueKind::PointExpr); + } values } + pub(crate) fn point_value_sources(&self) -> VerifierPointSourceSet { + self.point_values().source_set() + } + pub(crate) fn opening_point_sources(&self) -> BTreeSet { let mut values = BTreeSet::new(); values.extend(self.drivers.iter().map(|driver| driver.symbol.clone())); @@ -2294,11 +2293,13 @@ mod tests { StructuredPolynomialPointSegment, }; use crate::protocols::jolt::verifier_values::{ - VerifierFieldVectorValueRef, VerifierScalarValueKind, VerifierScalarValuePlan, + VerifierFieldVectorValueRef, VerifierPointValueRef, VerifierScalarValueKind, + VerifierScalarValuePlan, }; use super::{ - VerifierFieldExprPlan, VerifierScalarExprOperand, VerifierScalarExprPlan, VerifierStagePlan, + VerifierFieldExprPlan, VerifierPointExprKind, VerifierPointExprPlan, + VerifierScalarExprOperand, VerifierScalarExprPlan, VerifierStagePlan, }; #[test] @@ -2416,6 +2417,24 @@ mod tests { assert!(!values.contains_ref(&VerifierFieldVectorValueRef::new("missing.family"))); } + #[test] + fn point_values_classify_point_exprs() { + let mut plan = VerifierStagePlan::default(); + plan.point_exprs.push(VerifierPointExprPlan { + symbol: "point.value".to_owned(), + kind: VerifierPointExprKind::Zero { + field: "bn254_fr".to_owned(), + arity: 2, + }, + operands: Vec::new(), + }); + + let values = plan.point_values(); + + assert!(values.contains_ref(&VerifierPointValueRef::new("point.value"))); + assert!(!values.contains_ref(&VerifierPointValueRef::new("missing.point"))); + } + fn structured_polynomial_eval(symbol: &str) -> StructuredPolynomialEvalPlan { StructuredPolynomialEvalPlan { symbol: symbol.to_owned(), diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 9831051366..2f13bae52b 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -237,6 +237,23 @@ pub enum VerifierPointSourceKind { PointExpr, } +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum VerifierPointValueKind { + OpeningInput, + SumcheckInstance, + PointExpr, +} + +impl VerifierPointValueKind { + fn source_kind(self) -> VerifierPointSourceKind { + match self { + Self::OpeningInput => VerifierPointSourceKind::OpeningInput, + Self::SumcheckInstance => VerifierPointSourceKind::SumcheckInstance, + Self::PointExpr => VerifierPointSourceKind::PointExpr, + } + } +} + #[derive(Clone, Debug, PartialEq, Eq)] pub struct VerifierPointValueRef { symbol: String, @@ -254,6 +271,51 @@ impl VerifierPointValueRef { } } +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub(crate) struct VerifierPointValueSet { + symbols: BTreeMap, + conflicts: Vec>, +} + +impl VerifierPointValueSet { + pub(crate) fn insert(&mut self, symbol: &str, kind: VerifierPointValueKind) { + match self.symbols.entry(symbol.to_owned()) { + std::collections::btree_map::Entry::Vacant(entry) => { + let _entry = entry.insert(kind); + } + std::collections::btree_map::Entry::Occupied(entry) => { + let existing = *entry.get(); + if existing != kind { + self.conflicts.push(VerifierSourceConflict { + symbol: symbol.to_owned(), + existing, + incoming: kind, + }); + } + } + } + } + + pub(crate) fn contains_ref(&self, value_ref: &VerifierPointValueRef) -> bool { + self.symbols.contains_key(value_ref.symbol()) + } + + pub(crate) fn source_set(&self) -> VerifierPointSourceSet { + let mut sources = VerifierPointSourceSet::default(); + for (symbol, kind) in &self.symbols { + sources.insert(symbol, kind.source_kind()); + } + sources + } + + pub(crate) fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { + let Some(conflict) = self.conflicts.first() else { + return Ok(()); + }; + Err(conflicting_source_error(stage, "point value", conflict)) + } +} + #[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct VerifierPointSourceSet { symbols: BTreeMap, @@ -293,10 +355,6 @@ impl VerifierPointSourceSet { self.symbols.contains_key(symbol) } - pub(crate) fn contains_ref(&self, value_ref: &VerifierPointValueRef) -> bool { - self.symbols.contains_key(value_ref.symbol()) - } - pub(crate) fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { let Some(conflict) = self.conflicts.first() else { return Ok(()); From 3fc10900e2f00e00b50d929857849b0af3cdfa25 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 10:42:01 -0600 Subject: [PATCH 158/171] refactor(verifier): type relation point refs Validate relation-output structured polynomial points through verifier point value refs and remove the unused point source adapter. --- .../src/protocols/jolt/emit/rust/stage3.rs | 2 +- .../src/protocols/jolt/emit/rust/stage4.rs | 2 +- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../src/protocols/jolt/emit/rust/stage6.rs | 2 +- .../src/protocols/jolt/emit/rust/stage7.rs | 2 +- .../jolt/stage5_instruction_read_raf_plan.rs | 5 +- .../bolt/src/protocols/jolt/verifier_plan.rs | 12 +- .../jolt/verifier_relation_outputs.rs | 108 ++++++++++++++---- 8 files changed, 95 insertions(+), 40 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 82002522dd..2654b325e1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -611,7 +611,7 @@ impl Stage3CpuProgram { let plan = self.verifier_plan()?; let field_values = plan.scalar_values(); let field_vector_values = plan.field_vector_values(); - let point_values = plan.point_value_sources(); + let point_values = plan.point_values(); verifier_relation_outputs::verify_relation_outputs( "stage3", verifier_relation_outputs::RelationOutputVerification { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 480de8f47a..d43cbba997 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -633,7 +633,7 @@ impl Stage4CpuProgram { let plan = self.verifier_plan()?; let field_values = plan.scalar_values(); let field_vector_values = plan.field_vector_values(); - let point_values = plan.point_value_sources(); + let point_values = plan.point_values(); verifier_relation_outputs::verify_relation_outputs( "stage4", verifier_relation_outputs::RelationOutputVerification { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 14c2c1e8e4..8ac1c65bc9 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -735,7 +735,7 @@ impl Stage5CpuProgram { let plan = self.verifier_plan()?; let field_values = plan.scalar_values(); let field_vector_values = plan.field_vector_values(); - let point_values = plan.point_value_sources(); + let point_values = plan.point_values(); verifier_relation_outputs::verify_relation_outputs( "stage5", verifier_relation_outputs::RelationOutputVerification { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 9fe69342e4..4d1db8cd9d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -749,7 +749,7 @@ impl Stage6CpuProgram { let plan = self.verifier_plan()?; let field_values = plan.scalar_values(); let field_vector_values = plan.field_vector_values(); - let point_values = plan.point_value_sources(); + let point_values = plan.point_values(); verifier_relation_outputs::verify_relation_outputs( "stage6", verifier_relation_outputs::RelationOutputVerification { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 79a76b973c..1cea1e8ba3 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -849,7 +849,7 @@ impl Stage7CpuProgram { let plan = self.verifier_plan()?; let field_values = plan.scalar_values(); let field_vector_values = plan.field_vector_values(); - let point_values = plan.point_value_sources(); + let point_values = plan.point_values(); verifier_relation_outputs::verify_relation_outputs( "stage7", verifier_relation_outputs::RelationOutputVerification { diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index e29e467dc6..dfeac89949 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -8,6 +8,7 @@ use crate::protocols::jolt::verifier_relation_outputs::{ StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointPlan, StructuredPolynomialPointSegment, }; +use crate::protocols::jolt::verifier_values::VerifierPointValueRef; pub(crate) const STAGE5_TABLE_FLAG_EVAL_FAMILY: &str = "stage5.instruction_read_raf.eval.LookupTableFlag"; @@ -94,13 +95,13 @@ impl Stage5InstructionReadRafEmitPlan { symbol: format!("{PREFIX}.eq.LookupOutputCycle"), polynomial: StructuredPolynomialKind::Eq, x_point: StructuredPolynomialPointPlan { - source: self.point.clone(), + source: VerifierPointValueRef::new(self.point.clone()), segment: StructuredPolynomialPointSegment::Suffix, length: StructuredPolynomialPointLength::YPoint, order: StructuredPolynomialPointOrder::Reverse, }, y_point: StructuredPolynomialPointPlan { - source: self.lookup_output_point.clone(), + source: VerifierPointValueRef::new(self.lookup_output_point.clone()), segment: StructuredPolynomialPointSegment::Full, length: StructuredPolynomialPointLength::Full, order: StructuredPolynomialPointOrder::AsIs, diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 08a3f2005f..aeb9c7a939 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -31,9 +31,9 @@ use crate::protocols::jolt::verifier_value_rows::{ }; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorValueKind, VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, - VerifierPointSourceSet, VerifierPointValueKind, VerifierPointValueRef, VerifierPointValueSet, - VerifierScalarSourceSet, VerifierScalarValueKind, VerifierScalarValuePlan, - VerifierScalarValueRef, VerifierScalarValueSet, + VerifierPointValueKind, VerifierPointValueRef, VerifierPointValueSet, VerifierScalarSourceSet, + VerifierScalarValueKind, VerifierScalarValuePlan, VerifierScalarValueRef, + VerifierScalarValueSet, }; #[derive(Clone, Debug, PartialEq, Eq)] @@ -609,10 +609,6 @@ impl VerifierStagePlan { values } - pub(crate) fn point_value_sources(&self) -> VerifierPointSourceSet { - self.point_values().source_set() - } - pub(crate) fn opening_point_sources(&self) -> BTreeSet { let mut values = BTreeSet::new(); values.extend(self.drivers.iter().map(|driver| driver.symbol.clone())); @@ -2446,7 +2442,7 @@ mod tests { fn structured_polynomial_point(source: &str) -> StructuredPolynomialPointPlan { StructuredPolynomialPointPlan { - source: source.to_owned(), + source: VerifierPointValueRef::new(source), segment: StructuredPolynomialPointSegment::Full, length: StructuredPolynomialPointLength::Full, order: StructuredPolynomialPointOrder::AsIs, diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index ec9154b669..985c1152d9 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -12,9 +12,9 @@ use crate::protocols::jolt::rust_target_plan::{ power_strided_weighted_sum_formula, structured_polynomial_scalar_formula, }; use crate::protocols::jolt::verifier_values::{ - VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointSourceSet, - VerifierScalarValueKind, VerifierScalarValuePlan, VerifierScalarValueRef, - VerifierScalarValueSet, + VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointValueRef, + VerifierPointValueSet, VerifierScalarValueKind, VerifierScalarValuePlan, + VerifierScalarValueRef, VerifierScalarValueSet, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -156,7 +156,7 @@ impl PartialEq<&str> for RelationOutputFunctionKind { #[derive(Clone, Debug, PartialEq, Eq)] pub struct StructuredPolynomialPointPlan { - pub source: String, + pub source: VerifierPointValueRef, pub segment: StructuredPolynomialPointSegment, pub length: StructuredPolynomialPointLength, pub order: StructuredPolynomialPointOrder, @@ -170,7 +170,7 @@ impl StructuredPolynomialPointPlan { order: String, ) -> Result { Ok(Self { - source, + source: VerifierPointValueRef::new(source), segment: StructuredPolynomialPointSegment::from_cpu_attr(&segment)?, length: StructuredPolynomialPointLength::from_cpu_attr(&length)?, order: StructuredPolynomialPointOrder::from_cpu_attr(&order)?, @@ -239,7 +239,10 @@ pub fn structured_polynomial_scalar_expr_plan( value.y_point.length.as_str(), value.y_point.order.as_str(), ), - operands: vec![value.x_point.source.clone(), value.y_point.source.clone()], + operands: vec![ + value.x_point.source.symbol().to_owned(), + value.y_point.source.symbol().to_owned(), + ], } } @@ -1364,7 +1367,7 @@ pub struct RelationOutputVerification<'a> { pub relations: &'a BTreeSet, pub field_values: &'a VerifierScalarValueSet, pub field_vector_values: &'a VerifierFieldVectorValueSet, - pub point_values: &'a VerifierPointSourceSet, + pub point_values: &'a VerifierPointValueSet, } pub fn verify_relation_outputs( @@ -1385,16 +1388,18 @@ pub fn verify_relation_outputs( field_values.verify_no_conflicts(stage)?; point_values.verify_no_conflicts(stage)?; for polynomial_eval in relation_output_values { - if !point_values.contains(&polynomial_eval.x_point.source) { + if !point_values.contains_ref(&polynomial_eval.x_point.source) { return Err(EmitError::new(format!( "{stage} structured polynomial eval @{} references missing x-point @{}", - polynomial_eval.symbol, polynomial_eval.x_point.source + polynomial_eval.symbol, + polynomial_eval.x_point.source.symbol() ))); } - if !point_values.contains(&polynomial_eval.y_point.source) { + if !point_values.contains_ref(&polynomial_eval.y_point.source) { return Err(EmitError::new(format!( "{stage} structured polynomial eval @{} references missing y-point @{}", - polynomial_eval.symbol, polynomial_eval.y_point.source + polynomial_eval.symbol, + polynomial_eval.y_point.source.symbol() ))); } } @@ -1610,8 +1615,9 @@ mod tests { use crate::emit::rust::EmitError; use crate::protocols::jolt::verifier_values::{ - VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointSourceKind, - VerifierPointSourceSet, VerifierScalarValueKind, VerifierScalarValueSet, + VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointValueKind, + VerifierPointValueRef, VerifierPointValueSet, VerifierScalarValueKind, + VerifierScalarValueSet, }; use super::{ @@ -1647,13 +1653,13 @@ mod tests { symbol: "eq.output".to_owned(), polynomial: StructuredPolynomialKind::EqPlusOne, x_point: StructuredPolynomialPointPlan { - source: "x.source".to_owned(), + source: VerifierPointValueRef::new("x.source"), segment: StructuredPolynomialPointSegment::Prefix, length: StructuredPolynomialPointLength::YPoint, order: StructuredPolynomialPointOrder::Reverse, }, y_point: StructuredPolynomialPointPlan { - source: "y.source".to_owned(), + source: VerifierPointValueRef::new("y.source"), segment: StructuredPolynomialPointSegment::Full, length: StructuredPolynomialPointLength::Full, order: StructuredPolynomialPointOrder::AsIs, @@ -1838,7 +1844,7 @@ mod tests { field_values.insert("value", VerifierScalarValueKind::OpeningInput); field_values.insert("value", VerifierScalarValueKind::FieldExpr); let field_vector_values = VerifierFieldVectorValueSet::default(); - let point_values = VerifierPointSourceSet::default(); + let point_values = VerifierPointValueSet::default(); let relations = BTreeSet::new(); let error = match verify_relation_outputs( @@ -1870,12 +1876,12 @@ mod tests { } #[test] - fn relation_output_verification_rejects_conflicting_point_sources() -> Result<(), EmitError> { + fn relation_output_verification_rejects_conflicting_point_values() -> Result<(), EmitError> { let field_values = VerifierScalarValueSet::default(); let field_vector_values = VerifierFieldVectorValueSet::default(); - let mut point_values = VerifierPointSourceSet::default(); - point_values.insert("point", VerifierPointSourceKind::OpeningInput); - point_values.insert("point", VerifierPointSourceKind::PointExpr); + let mut point_values = VerifierPointValueSet::default(); + point_values.insert("point", VerifierPointValueKind::OpeningInput); + point_values.insert("point", VerifierPointValueKind::PointExpr); let relations = BTreeSet::new(); let error = match verify_relation_outputs( @@ -1901,7 +1907,59 @@ mod tests { }; assert!(error.to_string().contains( - "stage point source @point has conflicting kinds OpeningInput and PointExpr" + "stage point value source @point has conflicting kinds OpeningInput and PointExpr" + )); + Ok(()) + } + + #[test] + fn relation_output_verification_requires_planned_point_refs() -> Result<(), EmitError> { + let field_values = VerifierScalarValueSet::default(); + let field_vector_values = VerifierFieldVectorValueSet::default(); + let mut point_values = VerifierPointValueSet::default(); + point_values.insert("point.y", VerifierPointValueKind::OpeningInput); + let relations = BTreeSet::new(); + let relation_output_values = [StructuredPolynomialEvalPlan { + symbol: "eq.output".to_owned(), + polynomial: StructuredPolynomialKind::Eq, + x_point: StructuredPolynomialPointPlan { + source: VerifierPointValueRef::new("missing.point"), + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + y_point: StructuredPolynomialPointPlan { + source: VerifierPointValueRef::new("point.y"), + segment: StructuredPolynomialPointSegment::Full, + length: StructuredPolynomialPointLength::Full, + order: StructuredPolynomialPointOrder::AsIs, + }, + }]; + + let error = match verify_relation_outputs( + "stage", + RelationOutputVerification { + relation_output_values: &relation_output_values, + relation_output_eval_families: &[], + relation_output_product_families: &[], + relation_output_function_families: &[], + relation_outputs: &[], + relations: &relations, + field_values: &field_values, + field_vector_values: &field_vector_values, + point_values: &point_values, + }, + ) { + Ok(()) => { + return Err(EmitError::new( + "missing point ref should fail relation output verification", + )); + } + Err(error) => error, + }; + + assert!(error.to_string().contains( + "stage structured polynomial eval @eq.output references missing x-point @missing.point" )); Ok(()) } @@ -1911,7 +1969,7 @@ mod tests { let mut field_values = VerifierScalarValueSet::default(); field_values.insert("claim", VerifierScalarValueKind::FieldExpr); let field_vector_values = VerifierFieldVectorValueSet::default(); - let point_values = VerifierPointSourceSet::default(); + let point_values = VerifierPointValueSet::default(); let relations = BTreeSet::from(["relation".to_owned()]); let relation_outputs = [RelationOutputPlan::with_local_scalars( "relation", @@ -1953,7 +2011,7 @@ mod tests { field_values.insert("family.gamma", VerifierScalarValueKind::TranscriptScalar); field_values.insert("family.eval", VerifierScalarValueKind::SumcheckEval); let field_vector_values = VerifierFieldVectorValueSet::default(); - let point_values = VerifierPointSourceSet::default(); + let point_values = VerifierPointValueSet::default(); let relations = BTreeSet::new(); let family = RelationOutputEvalFamilyPlan { symbol: "family".to_owned(), @@ -2000,7 +2058,7 @@ mod tests { fn relation_output_verification_requires_planned_field_vector_refs() -> Result<(), EmitError> { let field_values = VerifierScalarValueSet::default(); let field_vector_values = VerifierFieldVectorValueSet::default(); - let point_values = VerifierPointSourceSet::default(); + let point_values = VerifierPointValueSet::default(); let relations = BTreeSet::new(); let family = RelationOutputProductFamilyPlan { symbol: "product.family".to_owned(), @@ -2047,7 +2105,7 @@ mod tests { field_values.insert("claim", VerifierScalarValueKind::FieldExpr); field_values.insert("local.scalar", VerifierScalarValueKind::FieldExpr); let field_vector_values = VerifierFieldVectorValueSet::default(); - let point_values = VerifierPointSourceSet::default(); + let point_values = VerifierPointValueSet::default(); let relations = BTreeSet::from(["relation".to_owned()]); let relation_outputs = [RelationOutputPlan::with_local_scalars( "relation", From e53a5acfbc6afd689c9645904ecd30ef36090f15 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 10:46:07 -0600 Subject: [PATCH 159/171] refactor(verifier): type stage2 point values Classify Stage 2 verifier point symbols with VerifierPointValueSet and delete stale point source conflict helpers. --- .../src/protocols/jolt/emit/rust/stage2.rs | 61 +++++++++++-------- .../src/protocols/jolt/verifier_values.rs | 34 +---------- 2 files changed, 36 insertions(+), 59 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index db2da59fea..96338e0192 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -981,9 +981,10 @@ impl Stage2CpuProgram { } if self.role == Role::Verifier { let field_values = self.verifier_scalar_sources(); - let point_values = self.verifier_point_sources(); + let verifier_point_values = self.verifier_point_values(); + let point_values = verifier_point_values.source_set(); field_values.verify_no_conflicts("stage2")?; - point_values.verify_no_conflicts("stage2")?; + verifier_point_values.verify_no_conflicts("stage2")?; for expr in &self.scalar_exprs { super::plan_tokens::verify_scalar_expr_operands( super::plan_tokens::ScalarExprVerification { @@ -1070,30 +1071,38 @@ impl Stage2CpuProgram { values } - fn verifier_point_sources(&self) -> verifier_values::VerifierPointSourceSet { - let mut values = verifier_values::VerifierPointSourceSet::default(); - values.extend( - self.opening_inputs.iter().map(|input| &input.symbol), - verifier_values::VerifierPointSourceKind::OpeningInput, - ); - values.extend( - self.drivers.iter().map(|driver| &driver.symbol), - verifier_values::VerifierPointSourceKind::SumcheckInstance, - ); - values.extend( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - verifier_values::VerifierPointSourceKind::SumcheckInstance, - ); - values.extend( - self.point_slices.iter().map(|slice| &slice.symbol), - verifier_values::VerifierPointSourceKind::PointExpr, - ); - values.extend( - self.point_concats.iter().map(|concat| &concat.symbol), - verifier_values::VerifierPointSourceKind::PointExpr, - ); + fn verifier_point_values(&self) -> verifier_values::VerifierPointValueSet { + let mut values = verifier_values::VerifierPointValueSet::default(); + for input in &self.opening_inputs { + values.insert( + &input.symbol, + verifier_values::VerifierPointValueKind::OpeningInput, + ); + } + for driver in &self.drivers { + values.insert( + &driver.symbol, + verifier_values::VerifierPointValueKind::SumcheckInstance, + ); + } + for instance in &self.instance_results { + values.insert( + &instance.symbol, + verifier_values::VerifierPointValueKind::SumcheckInstance, + ); + } + for slice in &self.point_slices { + values.insert( + &slice.symbol, + verifier_values::VerifierPointValueKind::PointExpr, + ); + } + for concat in &self.point_concats { + values.insert( + &concat.symbol, + verifier_values::VerifierPointValueKind::PointExpr, + ); + } values } diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index 2f13bae52b..a6380b45dd 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -319,48 +319,16 @@ impl VerifierPointValueSet { #[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct VerifierPointSourceSet { symbols: BTreeMap, - conflicts: Vec>, } impl VerifierPointSourceSet { pub fn insert(&mut self, symbol: &str, kind: VerifierPointSourceKind) { - match self.symbols.entry(symbol.to_owned()) { - std::collections::btree_map::Entry::Vacant(entry) => { - let _entry = entry.insert(kind); - } - std::collections::btree_map::Entry::Occupied(entry) => { - let existing = *entry.get(); - if existing != kind { - self.conflicts.push(VerifierSourceConflict { - symbol: symbol.to_owned(), - existing, - incoming: kind, - }); - } - } - } - } - - pub fn extend<'a>( - &mut self, - symbols: impl IntoIterator, - kind: VerifierPointSourceKind, - ) { - for symbol in symbols { - self.insert(symbol, kind); - } + let _entry = self.symbols.entry(symbol.to_owned()).or_insert(kind); } pub fn contains(&self, symbol: &str) -> bool { self.symbols.contains_key(symbol) } - - pub(crate) fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { - let Some(conflict) = self.conflicts.first() else { - return Ok(()); - }; - Err(conflicting_source_error(stage, "point", conflict)) - } } #[derive(Clone, Debug, PartialEq, Eq)] From 82ef59145c3b769f377b11fcfb4bf261a496d5ec Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 10:51:16 -0600 Subject: [PATCH 160/171] refactor(verifier): type stage2 scalar refs Validate Stage 2 verifier scalar expressions through typed verifier scalar and point value refs, and remove stale scalar source conflict helpers. --- .../src/protocols/jolt/emit/rust/stage2.rs | 106 ++++++++++-------- .../src/protocols/jolt/verifier_values.rs | 24 +--- 2 files changed, 63 insertions(+), 67 deletions(-) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 96338e0192..c5b0becdd1 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -980,22 +980,23 @@ impl Stage2CpuProgram { } } if self.role == Role::Verifier { - let field_values = self.verifier_scalar_sources(); + let field_values = self.verifier_scalar_values(); let verifier_point_values = self.verifier_point_values(); - let point_values = verifier_point_values.source_set(); field_values.verify_no_conflicts("stage2")?; verifier_point_values.verify_no_conflicts("stage2")?; for expr in &self.scalar_exprs { - super::plan_tokens::verify_scalar_expr_operands( - super::plan_tokens::ScalarExprVerification { + let expr = verifier_plan::VerifierScalarExprPlan::from_cpu( + &expr.symbol, + &expr.formula, + &expr.operands, + )?; + super::plan_tokens::verify_verifier_scalar_expr_operands( + super::plan_tokens::VerifierScalarExprVerification { stage: "stage2", - symbol: &expr.symbol, - formula: &expr.formula, - operand_names: &expr.operand_names, - operands: &expr.operands, + expr: &expr, field_values: &field_values, field_vector_values: None, - point_values: Some(&point_values), + point_values: Some(&verifier_point_values), }, )?; } @@ -1033,41 +1034,58 @@ impl Stage2CpuProgram { values } - fn verifier_scalar_sources(&self) -> verifier_values::VerifierScalarSourceSet { - let mut values = verifier_values::VerifierScalarSourceSet::default(); - values.extend( - self.opening_inputs.iter().map(|input| &input.symbol), - verifier_values::VerifierScalarSourceKind::OpeningInput, - ); - values.extend( - self.field_constants.iter().map(|constant| &constant.symbol), - verifier_values::VerifierScalarSourceKind::FieldConstant, - ); - values.extend( - self.transcript_squeezes - .iter() - .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) - .map(|squeeze| &squeeze.symbol), - verifier_values::VerifierScalarSourceKind::TranscriptScalar, - ); - values.extend( - self.field_exprs.iter().map(|expr| &expr.symbol), - verifier_values::VerifierScalarSourceKind::FieldExpr, - ); - values.extend( - self.scalar_exprs.iter().map(|expr| &expr.symbol), - verifier_values::VerifierScalarSourceKind::ScalarExpr, - ); - values.extend( - self.relation_outputs - .iter() - .flat_map(|output| output.local_scalar_symbols()), - verifier_values::VerifierScalarSourceKind::RelationOutputLocal, - ); - values.extend( - self.evals.iter().map(|eval| &eval.symbol), - verifier_values::VerifierScalarSourceKind::SumcheckEval, - ); + fn verifier_scalar_values(&self) -> verifier_values::VerifierScalarValueSet { + let mut values = verifier_values::VerifierScalarValueSet::default(); + for input in &self.opening_inputs { + values.insert( + &input.symbol, + verifier_values::VerifierScalarValueKind::OpeningInput, + ); + } + for constant in &self.field_constants { + values.insert( + &constant.symbol, + verifier_values::VerifierScalarValueKind::FieldConstant, + ); + } + for squeeze in self + .transcript_squeezes + .iter() + .filter(|squeeze| matches!(squeeze.kind.as_str(), "challenge_scalar" | "scalar")) + { + values.insert( + &squeeze.symbol, + verifier_values::VerifierScalarValueKind::TranscriptScalar, + ); + } + for expr in &self.field_exprs { + values.insert( + &expr.symbol, + verifier_values::VerifierScalarValueKind::FieldExpr, + ); + } + for expr in &self.scalar_exprs { + values.insert( + &expr.symbol, + verifier_values::VerifierScalarValueKind::ScalarExpr, + ); + } + for local_scalar in self + .relation_outputs + .iter() + .flat_map(|output| output.local_scalar_symbols()) + { + values.insert( + local_scalar, + verifier_values::VerifierScalarValueKind::RelationOutputLocal, + ); + } + for eval in &self.evals { + values.insert( + &eval.symbol, + verifier_values::VerifierScalarValueKind::SumcheckEval, + ); + } values } diff --git a/crates/bolt/src/protocols/jolt/verifier_values.rs b/crates/bolt/src/protocols/jolt/verifier_values.rs index a6380b45dd..34cda20833 100644 --- a/crates/bolt/src/protocols/jolt/verifier_values.rs +++ b/crates/bolt/src/protocols/jolt/verifier_values.rs @@ -149,26 +149,11 @@ impl VerifierScalarValueSet { #[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct VerifierScalarSourceSet { symbols: BTreeMap, - conflicts: Vec>, } impl VerifierScalarSourceSet { pub fn insert(&mut self, symbol: &str, kind: VerifierScalarSourceKind) { - match self.symbols.entry(symbol.to_owned()) { - std::collections::btree_map::Entry::Vacant(entry) => { - let _entry = entry.insert(kind); - } - std::collections::btree_map::Entry::Occupied(entry) => { - let existing = *entry.get(); - if existing != kind { - self.conflicts.push(VerifierSourceConflict { - symbol: symbol.to_owned(), - existing, - incoming: kind, - }); - } - } - } + let _entry = self.symbols.entry(symbol.to_owned()).or_insert(kind); } pub fn extend<'a>( @@ -184,13 +169,6 @@ impl VerifierScalarSourceSet { pub fn contains(&self, symbol: &str) -> bool { self.symbols.contains_key(symbol) } - - pub(crate) fn verify_no_conflicts(&self, stage: &str) -> Result<(), EmitError> { - let Some(conflict) = self.conflicts.first() else { - return Ok(()); - }; - Err(conflicting_source_error(stage, "scalar", conflict)) - } } #[derive(Clone, Copy, Debug, PartialEq, Eq)] From 819d4c37500c00806494097f6335e40a08502c36 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 10:59:00 -0600 Subject: [PATCH 161/171] docs(verifier): align relation output plan --- crates/bolt/GOAL.md | 13 +++ crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 100 +++++++++++------- 2 files changed, 76 insertions(+), 37 deletions(-) diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index 82c76c1954..ed697086ac 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -56,6 +56,19 @@ The goal is to reduce the human-facing generated verifier surface by roughly an order of magnitude. Shared runtime code may exist, but it must be modular, boring to audit, and driven by explicit MLIR-derived plan data. +Current S2.75-S5 implementation status: + +- S3/S4/S5 have largely landed in the generated verifier shape: Stage 2-7 emit + typed scalar/point/vector/eval-family refs and `RelationOutputPlan` rows, old + eval-prefix reconstruction sites are gated at zero, and handwritten + `expected_stage67_*` output helpers are gone from generated/runtime code. +- S2.75 remains the main incomplete architecture item. The stack has typed + planning data (`VerifierStagePlan` and typed value sets), but the CPU-to-Rust + planning boundaries still need to become explicit named pass artifacts. +- Performance evidence remains a live completion gate. The SHA2-chain perf + oracles must be rerun for the interpreter-heavy slices before this goal is + closed. + ## Audit Tiers The verifier code is partitioned into three explicit audit tiers. The `Concrete diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 12eba9c875..85f5d49cca 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -562,6 +562,16 @@ consume a typed Rust-plan / verifier-plan representation produced by passes. - The Rust emitter's responsibility is mostly formatting typed const data and importing the right runtime/Jolt-boundary APIs. +### Current status + +The current stack has most of the typed planning data this section calls for: +`VerifierStagePlan` owns stage-local scalar, point, vector, eval-family, and +relation-output plan rows; generated Stage 2-7 code emits typed +`RelationOutputPlan` data; and the Rust emitters increasingly consume typed +refs rather than rebuilding meaning from raw strings. The remaining S2.75 work +is to make these boundaries explicit as named planning-pass artifacts and to +keep new verifier semantics from landing directly in Rust emitters. + --- ## S3: Typed verifier value graph + polynomial primitives @@ -909,22 +919,37 @@ that second interpreter is worth the extra audit surface. ### Dialect changes -Add a top-level `compute::relation` op that ties a relation kind to a typed -expected-output scalar: +The accepted S5 carrier is `compute.sumcheck_output_claim`, not an +expected-output-bearing `compute.relation` declaration. `compute.relation` +remains relation metadata: symbol, kind, domain, rounds, degree, and output +count. The expected-output scalar is a typed value-graph operand of +`compute.sumcheck_output_claim`, along with the relation symbol/kind and the +polynomial eval operands that make the output claim auditable: ```mlir -compute.relation { - sym_name = "stage6.booleanity" - kind = "Stage6Booleanity" - query_point = @stage6_booleanity_point - expected_output = @stage6_booleanity_expected +%expected = compute.field_expr ... : !compute.field +compute.sumcheck_output_claim %expected, %eval0, %eval1 { + sym_name = "stage6.booleanity.output", + stage = "stage6", + relation = @stage6.booleanity, + count = 2 : i64, + polynomial_evals = ["stage6.booleanity.eval0", "stage6.booleanity.eval1"] } ``` -Stage emitters lower this to a `RelationPlan` in the generated stage files. -The expression feeding `expected_output` should be ordinary typed value-graph +The CPU lowering preserves that shape as `cpu.sumcheck_output_claim`. Stage +emitters lower those rows into generated `RelationOutputPlan` data whose +`expected_output` field points at the typed scalar produced by the value graph. +The expression feeding `expected_output` must remain ordinary typed value-graph data, not hidden inside the emitter. +This keeps relation declarations and relation-output claims separate: + +- `compute.relation` declares the relation and its static verifier metadata. +- `compute.sumcheck_output_claim` binds a concrete output-claim scalar to that + relation for a verifier stage. +- Generated `RelationOutputPlan` rows are the Rust target-plan projection. + ### Tier C impact (acknowledged growth) The relation plans and their supporting scalar/point/vector value rows live in @@ -964,17 +989,19 @@ declarative. ### Acceptance criteria Same correctness gates plus: `expected_stage67_*` functions in Tier B -are deleted. New `compute::relation` ops and any value-graph ops they depend on -have validator coverage. `muldiv` passes in both modes. +are deleted. `compute.sumcheck_output_claim` and any value-graph ops it depends +on have validator coverage. Generated stages contain typed `RelationOutputPlan` +rows, and the cleanup gate reports `handwritten_expected_output_functions: 0`. +`muldiv` passes in both modes, and verifier-time perf evidence is recorded. ### Rollback This is the most invasive slice. If the relation interpreter design is wrong, S5 should be revertible by restoring the deleted -`expected_stage67_*` functions and removing the relation-plan emitter -output. Recommend keeping the per-relation hand-written code in a -preserved-for-comparison file in the worklog while S5 is being shaken -down. +`expected_stage67_*` functions and removing the `RelationOutputPlan` emitter +output. Do not keep the old helpers as a fallback in generated verifier code; +that would violate the full-cutover rule. If comparison material is needed, +keep it only in the local never-commit worklog while S5 is being shaken down. ### Estimated wall-clock @@ -1106,11 +1133,12 @@ typed verifier value graph (`Scalar`, `Point`, `FieldVector`, eval families) rather than a larger bag of scalar-only field-expression variants or runtime string dispatch. -S5 introduces `compute::relation` as generic relation metadata over the value -graph, not a Jolt-specific relation language. Closed relation enums live at the -protocol/stage boundary; the generic runtime is parameterized over the protocol -relation enum when it needs equality or dispatch. Opaque typed symbols are for -generic storage paths that do not branch on relation kind. +S5 keeps `compute.relation` as generic relation metadata and uses +`compute.sumcheck_output_claim` to bind a typed expected-output scalar to that +relation. This is not a Jolt-specific relation language. Closed relation enums +live at the protocol/stage boundary; the generic runtime is parameterized over +the protocol relation enum when it needs equality or dispatch. Opaque typed +symbols are for generic storage paths that do not branch on relation kind. S6 is explicitly Jolt-specific. If pursued, it goes under `crates/bolt/src/protocols/jolt/`, not in `bolt-verifier-runtime`. @@ -1150,11 +1178,12 @@ us real-data core-vs-Bolt setup/prove/verify/proof-size/RSS measurements, but their current thresholds are broad smoke limits. Treat them as necessary but not sufficient for interpreter-heavy slices. -Before S2.75, S3, or S5 lands, record a local verifier-time baseline from the -SHA2-chain perf oracle and rerun it after the slice. If a verifier-time change -is noisy, rerun before calling it real. If a repeatable regression remains, -either fix it or explicitly document why the readability/security gain is worth -the cost. Do not loosen perf thresholds to make a refactor pass. The existing +Before closing S2.75/S3/S5 completion, record verifier-time evidence from the +SHA2-chain perf oracle. For future interpreter-heavy slices, capture a local +baseline before the slice and rerun after it. If a verifier-time change is +noisy, rerun before calling it real. If a repeatable regression remains, either +fix it or explicitly document why the readability/security gain is worth the +cost. Do not loosen perf thresholds to make a refactor pass. The existing S2/S2.5 progress should keep its captured baselines as reference data. The expected trend is "no measurable verifier change," because the interpreter @@ -1230,19 +1259,16 @@ Add S2.75 planning seams next. [unconditional] Make CPU-to-Rust verifier planning explicit. Prevent new semantics from landing in emitters or runtime string dispatch. -Land S3 after planning seams. [unconditional] - Establish scalar/point/field-vector/eval-family value graph. - Convert Stage 3 then Stage 4 relation-output checks first. - Defer bytecode, RAM sparse, lookup-table, and univariate-skip special cases. - -Decide on S4 vs Markos' next slice. [coordinate] - S4 is independent of Markos' work; either order is fine. +Audit S3/S4/S5 completion. [unconditional] + Confirm scalar/point/field-vector/eval-family value graph coverage. + Keep `compute.sumcheck_output_claim` as the expected-output carrier and + `compute.relation` as static relation metadata. + Verify old eval-prefix reconstruction and `expected_stage67_*` helpers stay + deleted. -Pause before S5. [explicit human review] - Decide whether the relation-as-data shape is right for Jolt's - current and likely-future relations. If yes, land S5. If not, - stop here; the verifier is in a defensible state with Tier B at - ~350 LOC of typed Rust. +Capture verifier perf evidence. [unconditional] + Run the SHA2-chain core-vs-Bolt perf oracle and record verifier-time results + before closing the goal. S6 only on demand. [optional] Defer until there is a concrete second user or audit pressure. From 03f643635ae898ec14bf3e4e5ce7590652e3f362 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 11:12:51 -0600 Subject: [PATCH 162/171] refactor(verifier): name cpu planning passes --- crates/bolt/GOAL.md | 9 +- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 14 +- .../src/protocols/jolt/emit/rust/stage3.rs | 2 +- .../src/protocols/jolt/emit/rust/stage4.rs | 2 +- .../src/protocols/jolt/emit/rust/stage5.rs | 2 +- .../src/protocols/jolt/emit/rust/stage6.rs | 2 +- .../src/protocols/jolt/emit/rust/stage7.rs | 2 +- .../bolt/src/protocols/jolt/verifier_plan.rs | 210 +++++++++++++----- 8 files changed, 181 insertions(+), 62 deletions(-) diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index ed697086ac..7fe9ff8857 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -62,9 +62,12 @@ Current S2.75-S5 implementation status: typed scalar/point/vector/eval-family refs and `RelationOutputPlan` rows, old eval-prefix reconstruction sites are gated at zero, and handwritten `expected_stage67_*` output helpers are gone from generated/runtime code. -- S2.75 remains the main incomplete architecture item. The stack has typed - planning data (`VerifierStagePlan` and typed value sets), but the CPU-to-Rust - planning boundaries still need to become explicit named pass artifacts. +- S2.75 remains the main incomplete architecture item, but its central + CPU-to-Rust planning boundary is now explicit: `VerifierStagePlan` is built + through named planning functions for program steps, transcript flow, + sumchecks, value/relation outputs, and opening flow. Remaining S2.75 work is + concentrated in stage-specific additions and target validation still owned by + emitters. - Performance evidence remains a live completion gate. The SHA2-chain perf oracles must be rerun for the interpreter-heavy slices before this goal is closed. diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 85f5d49cca..8b8bc4b90b 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -568,9 +568,17 @@ The current stack has most of the typed planning data this section calls for: `VerifierStagePlan` owns stage-local scalar, point, vector, eval-family, and relation-output plan rows; generated Stage 2-7 code emits typed `RelationOutputPlan` data; and the Rust emitters increasingly consume typed -refs rather than rebuilding meaning from raw strings. The remaining S2.75 work -is to make these boundaries explicit as named planning-pass artifacts and to -keep new verifier semantics from landing directly in Rust emitters. +refs rather than rebuilding meaning from raw strings. The shared +`plan_verifier_stage_from_cpu_sources` entrypoint now makes the main S2.75 +boundaries explicit as named planning functions: +`resolve_cpu_program_steps`, `plan_transcript_flow`, +`plan_verifier_sumchecks`, `plan_field_and_relation_outputs`, and +`plan_opening_flow`. + +The remaining S2.75 work is narrower: keep stage-specific verifier additions +such as Stage 5/6 relation-local input plans out of Rust template logic where +possible, and continue moving target validation toward typed planning outputs +instead of stage-local emitter checks. --- diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 2654b325e1..cd83ac3e33 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -297,7 +297,7 @@ impl Stage3CpuProgram { } fn plan_verifier(&self) -> Result { - verifier_plan::stage_plan_from_cpu_sources(self) + verifier_plan::plan_verifier_stage_from_cpu_sources(self) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index d43cbba997..60ee3e83af 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -312,7 +312,7 @@ impl Stage4CpuProgram { } fn plan_verifier(&self) -> Result { - verifier_plan::stage_plan_from_cpu_sources(self) + verifier_plan::plan_verifier_stage_from_cpu_sources(self) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 8ac1c65bc9..8b581324ae 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -385,7 +385,7 @@ impl Stage5CpuProgram { } fn plan_verifier(&self) -> Result { - let mut plan = verifier_plan::stage_plan_from_cpu_sources(self)?; + let mut plan = verifier_plan::plan_verifier_stage_from_cpu_sources(self)?; plan.relation_local_inputs.add_stage5_instruction_read_raf( Stage5InstructionReadRafEmitPlan::from_eval_families(&plan.indexed_eval_families)?, )?; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index 4d1db8cd9d..a792f49472 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -405,7 +405,7 @@ impl Stage6CpuProgram { } fn plan_verifier(&self) -> Result { - let mut plan = verifier_plan::stage_plan_from_cpu_sources(self)?; + let mut plan = verifier_plan::plan_verifier_stage_from_cpu_sources(self)?; plan.relation_local_inputs.add_stage6_bytecode_read_raf( Stage6BytecodeReadRafEmitPlan::from_eval_families(&plan.indexed_eval_families)?, )?; diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 1cea1e8ba3..5527cd59aa 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -515,7 +515,7 @@ impl Stage7CpuProgram { } fn plan_verifier(&self) -> Result { - verifier_plan::stage_plan_from_cpu_sources(self) + verifier_plan::plan_verifier_stage_from_cpu_sources(self) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index aeb9c7a939..f45f8524d3 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -1229,19 +1229,98 @@ impl VerifierSumcheckEvalSource for CpuSumcheckEvalPlan { } } -pub(crate) fn stage_plan_from_cpu_sources( +struct VerifierTranscriptPlanningOutput { + squeezes: Vec, + absorb_bytes: Vec, +} + +struct VerifierSumcheckPlanningOutput { + claims: Vec, + batches: Vec, + drivers: Vec, + instance_results: Vec, + evals: Vec, +} + +struct VerifierValueGraphPlanningOutput { + field_constants: Vec, + field_exprs: Vec, + scalar_exprs: Vec, + indexed_eval_families: Vec, + relation_output_values: Vec, + relation_output_eval_families: Vec, + relation_output_product_families: Vec, + relation_output_function_families: Vec, + relation_outputs: Vec, + point_exprs: Vec, +} + +struct VerifierOpeningFlowPlanningOutput { + inputs: Vec, + claims: Vec, + equalities: Vec, + batches: Vec, +} + +pub(crate) fn plan_verifier_stage_from_cpu_sources( source: &Source, ) -> Result where Source: VerifierStagePlanSource + ?Sized, { + let transcript = plan_transcript_flow(source)?; + let sumchecks = plan_verifier_sumchecks(source)?; + let value_graph = plan_field_and_relation_outputs(source)?; + let opening_flow = plan_opening_flow(source)?; + Ok(VerifierStagePlan { - steps: source - .steps() - .iter() - .map(|step| VerifierProgramStepPlan::from_cpu(step.kind(), step.symbol())) - .collect::, EmitError>>()?, - transcript_squeezes: source + steps: resolve_cpu_program_steps(source)?, + transcript_squeezes: transcript.squeezes, + transcript_absorb_bytes: transcript.absorb_bytes, + opening_inputs: opening_flow.inputs, + field_constants: value_graph.field_constants, + field_exprs: value_graph.field_exprs, + scalar_exprs: value_graph.scalar_exprs, + claims: sumchecks.claims, + batches: sumchecks.batches, + drivers: sumchecks.drivers, + instance_results: sumchecks.instance_results, + sumcheck_evals: sumchecks.evals, + indexed_eval_families: value_graph.indexed_eval_families, + relation_output_values: value_graph.relation_output_values, + relation_output_eval_families: value_graph.relation_output_eval_families, + relation_output_product_families: value_graph.relation_output_product_families, + relation_output_function_families: value_graph.relation_output_function_families, + relation_outputs: value_graph.relation_outputs, + relation_local_inputs: VerifierRelationLocalInputPlans::default(), + point_exprs: value_graph.point_exprs, + opening_claims: opening_flow.claims, + opening_equalities: opening_flow.equalities, + opening_batches: opening_flow.batches, + }) +} + +fn resolve_cpu_program_steps( + source: &Source, +) -> Result, EmitError> +where + Source: VerifierStagePlanSource + ?Sized, +{ + source + .steps() + .iter() + .map(|step| VerifierProgramStepPlan::from_cpu(step.kind(), step.symbol())) + .collect() +} + +fn plan_transcript_flow( + source: &Source, +) -> Result +where + Source: VerifierStagePlanSource + ?Sized, +{ + Ok(VerifierTranscriptPlanningOutput { + squeezes: source .transcript_squeezes() .iter() .map(|squeeze| { @@ -1253,45 +1332,17 @@ where ) }) .collect::, EmitError>>()?, - transcript_absorb_bytes: source.transcript_absorb_bytes(), - opening_inputs: source - .opening_inputs() - .iter() - .map(|opening_input| { - VerifierOpeningInputPlan::from_cpu( - opening_input.symbol(), - opening_input.source_stage(), - opening_input.source_claim(), - opening_input.oracle(), - opening_input.domain(), - opening_input.point_arity(), - opening_input.claim_kind(), - ) - }) - .collect::, EmitError>>()?, - field_constants: source - .field_constants() - .iter() - .map(|constant| VerifierFieldConstantPlan { - symbol: constant.symbol().to_owned(), - field: constant.field().to_owned(), - value: constant.value(), - }) - .collect(), - field_exprs: source - .field_exprs() - .iter() - .map(|expr| { - VerifierFieldExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands()) - }) - .collect::, EmitError>>()?, - scalar_exprs: source - .scalar_exprs() - .iter() - .map(|expr| { - VerifierScalarExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands()) - }) - .collect::, EmitError>>()?, + absorb_bytes: source.transcript_absorb_bytes(), + }) +} + +fn plan_verifier_sumchecks( + source: &Source, +) -> Result +where + Source: VerifierStagePlanSource + ?Sized, +{ + Ok(VerifierSumcheckPlanningOutput { claims: source .claims() .iter() @@ -1368,7 +1419,7 @@ where }) }) .collect::, EmitError>>()?, - sumcheck_evals: source + evals: source .sumcheck_evals() .iter() .map(|eval| VerifierSumcheckEvalPlan { @@ -1379,15 +1430,72 @@ where oracle: eval.oracle().to_owned(), }) .collect(), + }) +} + +fn plan_field_and_relation_outputs( + source: &Source, +) -> Result +where + Source: VerifierStagePlanSource + ?Sized, +{ + Ok(VerifierValueGraphPlanningOutput { + field_constants: source + .field_constants() + .iter() + .map(|constant| VerifierFieldConstantPlan { + symbol: constant.symbol().to_owned(), + field: constant.field().to_owned(), + value: constant.value(), + }) + .collect(), + field_exprs: source + .field_exprs() + .iter() + .map(|expr| { + VerifierFieldExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands()) + }) + .collect::, EmitError>>()?, + scalar_exprs: source + .scalar_exprs() + .iter() + .map(|expr| { + VerifierScalarExprPlan::from_cpu(expr.symbol(), expr.formula(), expr.operands()) + }) + .collect::, EmitError>>()?, indexed_eval_families: source.indexed_eval_families().to_vec(), relation_output_values: source.relation_output_values().to_vec(), relation_output_eval_families: source.relation_output_eval_families().to_vec(), relation_output_product_families: source.relation_output_product_families().to_vec(), relation_output_function_families: source.relation_output_function_families().to_vec(), relation_outputs: source.relation_outputs().to_vec(), - relation_local_inputs: VerifierRelationLocalInputPlans::default(), point_exprs: source.point_exprs(), - opening_claims: source + }) +} + +fn plan_opening_flow( + source: &Source, +) -> Result +where + Source: VerifierStagePlanSource + ?Sized, +{ + Ok(VerifierOpeningFlowPlanningOutput { + inputs: source + .opening_inputs() + .iter() + .map(|opening_input| { + VerifierOpeningInputPlan::from_cpu( + opening_input.symbol(), + opening_input.source_stage(), + opening_input.source_claim(), + opening_input.oracle(), + opening_input.domain(), + opening_input.point_arity(), + opening_input.claim_kind(), + ) + }) + .collect::, EmitError>>()?, + claims: source .opening_claims() .iter() .map(|claim| { @@ -1402,7 +1510,7 @@ where }) }) .collect::, EmitError>>()?, - opening_equalities: source + equalities: source .opening_equalities() .iter() .map(|equality| { @@ -1414,7 +1522,7 @@ where }) }) .collect::, EmitError>>()?, - opening_batches: source + batches: source .opening_batches() .iter() .map(|batch| VerifierOpeningBatchPlan { From 3df5077d17af94f428d695fb9366b80b092ac24a Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 11:17:20 -0600 Subject: [PATCH 163/171] refactor(verifier): plan relation local inputs --- crates/bolt/GOAL.md | 6 +-- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 8 ++-- .../src/protocols/jolt/emit/rust/stage5.rs | 7 +-- .../src/protocols/jolt/emit/rust/stage6.rs | 7 +-- .../bolt/src/protocols/jolt/verifier_plan.rs | 46 ++++++++++++++++++- 5 files changed, 56 insertions(+), 18 deletions(-) diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index 7fe9ff8857..a35b6467b2 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -65,9 +65,9 @@ Current S2.75-S5 implementation status: - S2.75 remains the main incomplete architecture item, but its central CPU-to-Rust planning boundary is now explicit: `VerifierStagePlan` is built through named planning functions for program steps, transcript flow, - sumchecks, value/relation outputs, and opening flow. Remaining S2.75 work is - concentrated in stage-specific additions and target validation still owned by - emitters. + sumchecks, value/relation outputs, opening flow, and Stage 5/6 relation-local + inputs. Remaining S2.75 work is concentrated in target validation still owned + by emitters. - Performance evidence remains a live completion gate. The SHA2-chain perf oracles must be rerun for the interpreter-heavy slices before this goal is closed. diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 8b8bc4b90b..7126671d82 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -575,10 +575,10 @@ boundaries explicit as named planning functions: `plan_verifier_sumchecks`, `plan_field_and_relation_outputs`, and `plan_opening_flow`. -The remaining S2.75 work is narrower: keep stage-specific verifier additions -such as Stage 5/6 relation-local input plans out of Rust template logic where -possible, and continue moving target validation toward typed planning outputs -instead of stage-local emitter checks. +Stage 5/6 relation-local input plans are also now produced through this shared +planning boundary. The remaining S2.75 work is narrower: continue moving target +validation toward typed planning outputs instead of stage-local emitter checks, +and avoid putting any new verifier semantics directly in Rust template logic. --- diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 8b581324ae..5bf623c59c 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -109,6 +109,7 @@ verifier_plan::impl_verifier_plan_source_traits!( relation_output_eval_families = relation_output_eval_families, relation_output_product_families = relation_output_product_families, relation_output_function_families = relation_output_function_families, + relation_local_inputs = stage5_instruction_read_raf, ); pub fn stage5_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -385,11 +386,7 @@ impl Stage5CpuProgram { } fn plan_verifier(&self) -> Result { - let mut plan = verifier_plan::plan_verifier_stage_from_cpu_sources(self)?; - plan.relation_local_inputs.add_stage5_instruction_read_raf( - Stage5InstructionReadRafEmitPlan::from_eval_families(&plan.indexed_eval_families)?, - )?; - Ok(plan) + verifier_plan::plan_verifier_stage_from_cpu_sources(self) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index a792f49472..b761537032 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -118,6 +118,7 @@ verifier_plan::impl_verifier_plan_source_traits!( relation_output_eval_families = relation_output_eval_families, relation_output_product_families = relation_output_product_families, relation_output_function_families = relation_output_function_families, + relation_local_inputs = stage6_bytecode_read_raf, ); pub fn stage6_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { @@ -405,11 +406,7 @@ impl Stage6CpuProgram { } fn plan_verifier(&self) -> Result { - let mut plan = verifier_plan::plan_verifier_stage_from_cpu_sources(self)?; - plan.relation_local_inputs.add_stage6_bytecode_read_raf( - Stage6BytecodeReadRafEmitPlan::from_eval_families(&plan.indexed_eval_families)?, - )?; - Ok(plan) + verifier_plan::plan_verifier_stage_from_cpu_sources(self) } fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index f45f8524d3..fded375182 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -799,6 +799,13 @@ pub(crate) trait VerifierStagePlanSource { &[] } fn relation_outputs(&self) -> &[RelationOutputPlan]; + fn relation_local_inputs( + &self, + indexed_eval_families: &[IndexedEvalFamilyPlan], + ) -> Result { + let _ = indexed_eval_families; + Ok(VerifierRelationLocalInputPlans::default()) + } fn point_exprs(&self) -> Vec; fn opening_claims(&self) -> &[CpuOpeningClaimPlan]; fn opening_equalities(&self) -> &[CpuOpeningClaimEqualityPlan]; @@ -1271,6 +1278,7 @@ where let transcript = plan_transcript_flow(source)?; let sumchecks = plan_verifier_sumchecks(source)?; let value_graph = plan_field_and_relation_outputs(source)?; + let relation_local_inputs = source.relation_local_inputs(&value_graph.indexed_eval_families)?; let opening_flow = plan_opening_flow(source)?; Ok(VerifierStagePlan { @@ -1292,7 +1300,7 @@ where relation_output_product_families: value_graph.relation_output_product_families, relation_output_function_families: value_graph.relation_output_function_families, relation_outputs: value_graph.relation_outputs, - relation_local_inputs: VerifierRelationLocalInputPlans::default(), + relation_local_inputs, point_exprs: value_graph.point_exprs, opening_claims: opening_flow.claims, opening_equalities: opening_flow.equalities, @@ -1635,6 +1643,7 @@ macro_rules! impl_verifier_plan_source_traits { $(relation_output_eval_families = $relation_output_eval_families:ident,)? $(relation_output_product_families = $relation_output_product_families:ident,)? $(relation_output_function_families = $relation_output_function_families:ident,)? + $(relation_local_inputs = $relation_local_inputs:ident,)? $(,)? ) => { impl $crate::protocols::jolt::verifier_plan::VerifierStagePlanSource for $program { @@ -1680,6 +1689,17 @@ macro_rules! impl_verifier_plan_source_traits { fn relation_outputs(&self) -> &[$crate::protocols::jolt::verifier_relation_outputs::RelationOutputPlan] { &self.relation_outputs } + fn relation_local_inputs( + &self, + indexed_eval_families: &[$crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan], + ) -> Result< + $crate::protocols::jolt::verifier_plan::VerifierRelationLocalInputPlans, + $crate::emit::rust::EmitError, + > { + $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( + @relation_local_inputs indexed_eval_families $(, $relation_local_inputs)? + ) + } fn point_exprs(&self) -> Vec<$crate::protocols::jolt::verifier_plan::VerifierPointExprPlan> { $crate::protocols::jolt::verifier_plan::impl_verifier_plan_source_traits!( @point_exprs self $(, $point_zero)? @@ -1736,6 +1756,30 @@ macro_rules! impl_verifier_plan_source_traits { (@relation_output_function_families $self:ident) => { &[] }; + (@relation_local_inputs $indexed_eval_families:ident, stage5_instruction_read_raf) => {{ + let mut plans = + $crate::protocols::jolt::verifier_plan::VerifierRelationLocalInputPlans::default(); + plans.add_stage5_instruction_read_raf( + $crate::protocols::jolt::stage5_instruction_read_raf_plan::Stage5InstructionReadRafEmitPlan::from_eval_families( + $indexed_eval_families, + )?, + )?; + Ok(plans) + }}; + (@relation_local_inputs $indexed_eval_families:ident, stage6_bytecode_read_raf) => {{ + let mut plans = + $crate::protocols::jolt::verifier_plan::VerifierRelationLocalInputPlans::default(); + plans.add_stage6_bytecode_read_raf( + $crate::protocols::jolt::stage6_bytecode_read_raf_plan::Stage6BytecodeReadRafEmitPlan::from_eval_families( + $indexed_eval_families, + )?, + )?; + Ok(plans) + }}; + (@relation_local_inputs $indexed_eval_families:ident) => {{ + let _ = $indexed_eval_families; + Ok($crate::protocols::jolt::verifier_plan::VerifierRelationLocalInputPlans::default()) + }}; } pub(crate) use impl_verifier_plan_source_traits; From f049915fc0a4b9c2cd377a8e0d968a892f1549bb Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 11:34:03 -0600 Subject: [PATCH 164/171] refactor(verifier): type relation output ids Carry relation-output plan rows with JoltVerifierRelationKind instead of raw strings and move repeated Stage 3-7 relation-output validation onto VerifierStagePlan. Keep relation symbols as diagnostics/adapter data only; generated verifier execution continues to consume typed relation plans. --- crates/bolt/GOAL.md | 10 ++-- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 20 ++++--- .../jolt/emit/rust/relation_outputs.rs | 4 +- .../src/protocols/jolt/emit/rust/stage2.rs | 14 ++--- .../src/protocols/jolt/emit/rust/stage3.rs | 24 +-------- .../src/protocols/jolt/emit/rust/stage4.rs | 24 +-------- .../src/protocols/jolt/emit/rust/stage5.rs | 24 +-------- .../src/protocols/jolt/emit/rust/stage6.rs | 24 +-------- .../src/protocols/jolt/emit/rust/stage7.rs | 24 +-------- .../src/protocols/jolt/rust_target_plan.rs | 38 +++++++++++++- .../jolt/stage5_instruction_read_raf_plan.rs | 8 +-- .../jolt/stage6_bytecode_read_raf_plan.rs | 9 +++- .../bolt/src/protocols/jolt/verifier_plan.rs | 27 +++++++++- .../jolt/verifier_relation_outputs.rs | 52 ++++++++++++------- crates/jolt-equivalence/src/plan_adapters.rs | 2 +- 15 files changed, 140 insertions(+), 164 deletions(-) diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index a35b6467b2..fa0838256c 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -59,15 +59,17 @@ boring to audit, and driven by explicit MLIR-derived plan data. Current S2.75-S5 implementation status: - S3/S4/S5 have largely landed in the generated verifier shape: Stage 2-7 emit - typed scalar/point/vector/eval-family refs and `RelationOutputPlan` rows, old - eval-prefix reconstruction sites are gated at zero, and handwritten + typed scalar/point/vector/eval-family refs and `RelationOutputPlan` rows with + closed relation IDs, old eval-prefix reconstruction sites are gated at zero, + and handwritten `expected_stage67_*` output helpers are gone from generated/runtime code. - S2.75 remains the main incomplete architecture item, but its central CPU-to-Rust planning boundary is now explicit: `VerifierStagePlan` is built through named planning functions for program steps, transcript flow, sumchecks, value/relation outputs, opening flow, and Stage 5/6 relation-local - inputs. Remaining S2.75 work is concentrated in target validation still owned - by emitters. + inputs. Relation-output validation is now owned by `VerifierStagePlan`. + Remaining S2.75 work is concentrated in target validation still owned by + emitters. - Performance evidence remains a live completion gate. The SHA2-chain perf oracles must be rerun for the interpreter-heavy slices before this goal is closed. diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 7126671d82..171978896d 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -567,8 +567,9 @@ consume a typed Rust-plan / verifier-plan representation produced by passes. The current stack has most of the typed planning data this section calls for: `VerifierStagePlan` owns stage-local scalar, point, vector, eval-family, and relation-output plan rows; generated Stage 2-7 code emits typed -`RelationOutputPlan` data; and the Rust emitters increasingly consume typed -refs rather than rebuilding meaning from raw strings. The shared +`RelationOutputPlan` data with closed relation IDs; and the Rust emitters +increasingly consume typed refs rather than rebuilding meaning from raw strings. +The shared `plan_verifier_stage_from_cpu_sources` entrypoint now makes the main S2.75 boundaries explicit as named planning functions: `resolve_cpu_program_steps`, `plan_transcript_flow`, @@ -576,9 +577,11 @@ boundaries explicit as named planning functions: `plan_opening_flow`. Stage 5/6 relation-local input plans are also now produced through this shared -planning boundary. The remaining S2.75 work is narrower: continue moving target -validation toward typed planning outputs instead of stage-local emitter checks, -and avoid putting any new verifier semantics directly in Rust template logic. +planning boundary, and relation-output validation now runs from +`VerifierStagePlan` instead of repeated stage-local string sets. The remaining +S2.75 work is narrower: continue moving target validation toward typed planning +outputs instead of stage-local emitter checks, and avoid putting any new +verifier semantics directly in Rust template logic. --- @@ -948,8 +951,11 @@ compute.sumcheck_output_claim %expected, %eval0, %eval1 { The CPU lowering preserves that shape as `cpu.sumcheck_output_claim`. Stage emitters lower those rows into generated `RelationOutputPlan` data whose `expected_output` field points at the typed scalar produced by the value graph. -The expression feeding `expected_output` must remain ordinary typed value-graph -data, not hidden inside the emitter. +Those rows also carry a closed `JoltVerifierRelationKind` relation ID; the +serialization symbol remains available for diagnostics and equivalence adapters, +but relation-output verification no longer treats raw strings as the execution +contract. The expression feeding `expected_output` must remain ordinary typed +value-graph data, not hidden inside the emitter. This keeps relation declarations and relation-output claims separate: diff --git a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs index b5afceea72..52d4e5b0bf 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/relation_outputs.rs @@ -4,7 +4,7 @@ use crate::protocols::jolt::verifier_relation_outputs::RelationOutputPlan; pub fn emit_verifier_relation_output_constants( stage_type: &str, - role: &Role, + _role: &Role, relation_outputs: &[RelationOutputPlan], ) -> Result { let mut source = String::new(); @@ -13,7 +13,7 @@ pub fn emit_verifier_relation_output_constants( let local_scalars = emit_local_scalar_constants(&mut source, stage_type, index, claim); claims.push(format!( " {stage_type}RelationOutputPlan {{ relation: {}, local_scalars: {local_scalars}, expected_output: {} }},", - super::plan_tokens::role_relation_kind_expr(stage_type, role, &claim.relation)?, + crate::protocols::jolt::verifier_plan::relation_kind_expr(stage_type, claim.relation()), rust_str(claim.expected_output_symbol()) )); } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index c5b0becdd1..3bbb6dc3f6 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -424,24 +424,24 @@ fn stage2_relation_output_plans() -> Stage2RelationOutputRows { ], relation_outputs: vec![ Stage2RelationOutputPlan::new( - "jolt.stage2.ram.read_write", + JoltVerifierRelationKind::Stage2RamReadWrite, "stage2.ram_read_write.output.claim_expr", ), Stage2RelationOutputPlan::new( - "jolt.stage2.instruction_lookup.claim_reduction", + JoltVerifierRelationKind::Stage2InstructionLookupClaimReduction, "stage2.instruction_lookup.output.claim_expr", ), Stage2RelationOutputPlan::new( - "jolt.stage2.product_virtual.remainder", + JoltVerifierRelationKind::Stage2ProductVirtualRemainder, "stage2.product_virtual.remainder.output.claim_expr", ), Stage2RelationOutputPlan::with_local_scalars( - "jolt.stage2.ram.raf_evaluation", + JoltVerifierRelationKind::Stage2RamRafEvaluation, ["stage2.ram_raf.output.unmap".to_owned()], "stage2.ram_raf.output.claim_expr", ), Stage2RelationOutputPlan::with_local_scalars( - "jolt.stage2.ram.output_check", + JoltVerifierRelationKind::Stage2RamOutputCheck, [ "stage2.ram_output.output.eq".to_owned(), "stage2.ram_output.output.io_mask".to_owned(), @@ -1339,10 +1339,6 @@ impl Stage2CpuProgram { let _ = JoltVerifierRelationKind::from_cpu_attr(&instance.relation) .map_err(rust_target_plan_error)?; } - for output in &self.relation_outputs { - let _ = JoltVerifierRelationKind::from_cpu_attr(&output.relation) - .map_err(rust_target_plan_error)?; - } for claim in &self.opening_claims { let _ = ClaimKind::from_cpu_attr(&claim.claim_kind).map_err(rust_target_plan_error)?; } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index cd83ac3e33..c17d676653 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -603,29 +603,7 @@ impl Stage3CpuProgram { } fn verify_relation_outputs(&self) -> Result<(), EmitError> { - let relations = symbols( - self.instance_results - .iter() - .map(|instance| &instance.relation), - ); - let plan = self.verifier_plan()?; - let field_values = plan.scalar_values(); - let field_vector_values = plan.field_vector_values(); - let point_values = plan.point_values(); - verifier_relation_outputs::verify_relation_outputs( - "stage3", - verifier_relation_outputs::RelationOutputVerification { - relation_output_values: &self.relation_output_values, - relation_output_eval_families: &[], - relation_output_product_families: &[], - relation_output_function_families: &[], - relation_outputs: &self.relation_outputs, - relations: &relations, - field_values: &field_values, - field_vector_values: &field_vector_values, - point_values: &point_values, - }, - ) + self.verifier_plan()?.verify_relation_outputs("stage3") } fn verify_opening_flow(&self) -> Result<(), EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 60ee3e83af..9688af4b51 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -625,29 +625,7 @@ impl Stage4CpuProgram { } fn verify_relation_outputs(&self) -> Result<(), EmitError> { - let relations = symbols( - self.instance_results - .iter() - .map(|instance| &instance.relation), - ); - let plan = self.verifier_plan()?; - let field_values = plan.scalar_values(); - let field_vector_values = plan.field_vector_values(); - let point_values = plan.point_values(); - verifier_relation_outputs::verify_relation_outputs( - "stage4", - verifier_relation_outputs::RelationOutputVerification { - relation_output_values: &self.relation_output_values, - relation_output_eval_families: &[], - relation_output_product_families: &[], - relation_output_function_families: &[], - relation_outputs: &self.relation_outputs, - relations: &relations, - field_values: &field_values, - field_vector_values: &field_vector_values, - point_values: &point_values, - }, - ) + self.verifier_plan()?.verify_relation_outputs("stage4") } fn verify_opening_flow(&self) -> Result<(), EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 5bf623c59c..cd805762ba 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -724,29 +724,7 @@ impl Stage5CpuProgram { } fn verify_relation_outputs(&self) -> Result<(), EmitError> { - let relations = symbols( - self.instance_results - .iter() - .map(|instance| &instance.relation), - ); - let plan = self.verifier_plan()?; - let field_values = plan.scalar_values(); - let field_vector_values = plan.field_vector_values(); - let point_values = plan.point_values(); - verifier_relation_outputs::verify_relation_outputs( - "stage5", - verifier_relation_outputs::RelationOutputVerification { - relation_output_values: &self.relation_output_values, - relation_output_eval_families: &self.relation_output_eval_families, - relation_output_product_families: &self.relation_output_product_families, - relation_output_function_families: &self.relation_output_function_families, - relation_outputs: &self.relation_outputs, - relations: &relations, - field_values: &field_values, - field_vector_values: &field_vector_values, - point_values: &point_values, - }, - ) + self.verifier_plan()?.verify_relation_outputs("stage5") } fn verify_opening_flow(&self) -> Result<(), EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index b761537032..bd36c3c080 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -738,29 +738,7 @@ impl Stage6CpuProgram { } fn verify_relation_outputs(&self) -> Result<(), EmitError> { - let relations = symbols( - self.instance_results - .iter() - .map(|instance| &instance.relation), - ); - let plan = self.verifier_plan()?; - let field_values = plan.scalar_values(); - let field_vector_values = plan.field_vector_values(); - let point_values = plan.point_values(); - verifier_relation_outputs::verify_relation_outputs( - "stage6", - verifier_relation_outputs::RelationOutputVerification { - relation_output_values: &self.relation_output_values, - relation_output_eval_families: &self.relation_output_eval_families, - relation_output_product_families: &self.relation_output_product_families, - relation_output_function_families: &self.relation_output_function_families, - relation_outputs: &self.relation_outputs, - relations: &relations, - field_values: &field_values, - field_vector_values: &field_vector_values, - point_values: &point_values, - }, - ) + self.verifier_plan()?.verify_relation_outputs("stage6") } fn verify_opening_flow(&self) -> Result<(), EmitError> { diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 5527cd59aa..7a26dccffe 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -841,29 +841,7 @@ impl Stage7CpuProgram { } fn verify_relation_outputs(&self) -> Result<(), EmitError> { - let relations = symbols( - self.instance_results - .iter() - .map(|instance| &instance.relation), - ); - let plan = self.verifier_plan()?; - let field_values = plan.scalar_values(); - let field_vector_values = plan.field_vector_values(); - let point_values = plan.point_values(); - verifier_relation_outputs::verify_relation_outputs( - "stage7", - verifier_relation_outputs::RelationOutputVerification { - relation_output_values: &self.relation_output_values, - relation_output_eval_families: &self.relation_output_eval_families, - relation_output_product_families: &self.relation_output_product_families, - relation_output_function_families: &self.relation_output_function_families, - relation_outputs: &self.relation_outputs, - relations: &relations, - field_values: &field_values, - field_vector_values: &field_vector_values, - point_values: &point_values, - }, - ) + self.verifier_plan()?.verify_relation_outputs("stage7") } fn verify_opening_flow(&self) -> Result<(), EmitError> { diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index 803e1af7d4..b132a9cd09 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -140,7 +140,7 @@ impl SumcheckPointOrder { } } -#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] pub(crate) enum JoltVerifierRelationKind { Stage1OuterUniskip, Stage1OuterRemaining, @@ -174,6 +174,42 @@ pub(crate) enum JoltVerifierRelationKind { } impl JoltVerifierRelationKind { + pub(crate) fn cpu_symbol(self) -> &'static str { + match self { + Self::Stage1OuterUniskip => "jolt.stage1.outer.uniskip", + Self::Stage1OuterRemaining => "jolt.stage1.outer.remaining", + Self::Stage2ProductVirtualUniskip => "jolt.stage2.product_virtual.uniskip", + Self::Stage2RamReadWrite => "jolt.stage2.ram.read_write", + Self::Stage2ProductVirtualRemainder => "jolt.stage2.product_virtual.remainder", + Self::Stage2InstructionLookupClaimReduction => { + "jolt.stage2.instruction_lookup.claim_reduction" + } + Self::Stage2RamRafEvaluation => "jolt.stage2.ram.raf_evaluation", + Self::Stage2RamOutputCheck => "jolt.stage2.ram.output_check", + Self::Stage2Batched => "jolt.stage2.batched", + Self::Stage3SpartanShift => "jolt.stage3.spartan_shift", + Self::Stage3InstructionInput => "jolt.stage3.instruction_input", + Self::Stage3RegistersClaimReduction => "jolt.stage3.registers_claim_reduction", + Self::Stage3Batched => "jolt.stage3.batched", + Self::Stage4RegistersReadWrite => "jolt.stage4.registers_read_write", + Self::Stage4RamValCheck => "jolt.stage4.ram_val_check", + Self::Stage4Batched => "jolt.stage4.batched", + Self::Stage5InstructionReadRaf => "jolt.stage5.instruction_read_raf", + Self::Stage5RamRaClaimReduction => "jolt.stage5.ram_ra_claim_reduction", + Self::Stage5RegistersValEvaluation => "jolt.stage5.registers_val_evaluation", + Self::Stage5Batched => "jolt.stage5.batched", + Self::Stage6BytecodeReadRaf => "jolt.stage6.bytecode_read_raf", + Self::Stage6Booleanity => "jolt.stage6.booleanity", + Self::Stage6HammingBooleanity => "jolt.stage6.hamming_booleanity", + Self::Stage6RamRaVirtual => "jolt.stage6.ram_ra_virtual", + Self::Stage6InstructionRaVirtual => "jolt.stage6.instruction_ra_virtual", + Self::Stage6IncClaimReduction => "jolt.stage6.inc_claim_reduction", + Self::Stage6Batched => "jolt.stage6.batched", + Self::Stage7HammingWeightClaimReduction => "jolt.stage7.hamming_weight_claim_reduction", + Self::Stage7Batched => "jolt.stage7.batched", + } + } + pub(crate) fn from_cpu_attr(value: &str) -> Result { match value { "jolt.stage1.outer.uniskip" => Ok(Self::Stage1OuterUniskip), diff --git a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs index dfeac89949..7b4bd47338 100644 --- a/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage5_instruction_read_raf_plan.rs @@ -1,4 +1,5 @@ use crate::emit::rust::{push_format, EmitError}; +use crate::protocols::jolt::rust_target_plan::JoltVerifierRelationKind; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_local_scalars::{ emit_jolt_local_scalar_constants, JoltLocalScalarEmitPlan, JoltLocalScalarMleKind, @@ -211,7 +212,7 @@ impl Stage5InstructionReadRafEmitPlan { relation_output_values: vec![eq.clone()], field_exprs, claim: RelationOutputPlan::with_local_scalars( - "jolt.stage5.instruction_read_raf", + JoltVerifierRelationKind::Stage5InstructionReadRaf, self.local_scalars.iter().map(|value| value.symbol.clone()), claim_expr, ), @@ -284,6 +285,7 @@ fn indexed_eval_family_ref(index: usize) -> String { #[cfg(test)] mod tests { use crate::emit::rust::EmitError; + use crate::protocols::jolt::rust_target_plan::JoltVerifierRelationKind; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use super::{ @@ -377,8 +379,8 @@ mod tests { let output_plan = plan.relation_output_plan(); assert_eq!( - output_plan.claim.relation, - "jolt.stage5.instruction_read_raf" + output_plan.claim.relation(), + JoltVerifierRelationKind::Stage5InstructionReadRaf ); assert_eq!( output_plan.claim.expected_output_symbol(), diff --git a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs index 51f534be8f..fa38295e95 100644 --- a/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs +++ b/crates/bolt/src/protocols/jolt/stage6_bytecode_read_raf_plan.rs @@ -1,4 +1,5 @@ use crate::emit::rust::{push_format, EmitError}; +use crate::protocols::jolt::rust_target_plan::JoltVerifierRelationKind; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use crate::protocols::jolt::verifier_relation_outputs::{ RelationOutputFieldExprPlan, RelationOutputPlan, @@ -426,7 +427,7 @@ impl BytecodeReadRafPlan { }, ], claim: RelationOutputPlan::with_local_scalars( - "jolt.stage6.bytecode_read_raf", + JoltVerifierRelationKind::Stage6BytecodeReadRaf, output_term_symbols, claim_expr, ), @@ -636,6 +637,7 @@ fn rust_option_str(value: Option<&str>) -> String { #[cfg(test)] mod tests { use crate::emit::rust::EmitError; + use crate::protocols::jolt::rust_target_plan::JoltVerifierRelationKind; use crate::protocols::jolt::verifier_eval_families::IndexedEvalFamilyPlan; use super::{ @@ -755,7 +757,10 @@ mod tests { .relation_output_plan(); let claim = output_plan.claim; - assert_eq!(claim.relation, "jolt.stage6.bytecode_read_raf"); + assert_eq!( + claim.relation(), + JoltVerifierRelationKind::Stage6BytecodeReadRaf + ); assert_eq!( claim.expected_output_symbol(), "stage6.bytecode_read_raf.output.claim_expr" diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index fded375182..964cf3a3bb 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -19,7 +19,7 @@ use crate::protocols::jolt::verifier_program_rows::{ CpuOpeningInputPlan, CpuProgramStepPlan, CpuTranscriptAbsorbBytesPlan, CpuTranscriptSqueezePlan, }; use crate::protocols::jolt::verifier_relation_outputs::{ - RelationOutputEvalFamilyPlan, RelationOutputFunctionFamilyPlan, RelationOutputPlan, + self, RelationOutputEvalFamilyPlan, RelationOutputFunctionFamilyPlan, RelationOutputPlan, RelationOutputProductFamilyPlan, StructuredPolynomialEvalPlan, }; use crate::protocols::jolt::verifier_sumcheck_rows::{ @@ -609,6 +609,31 @@ impl VerifierStagePlan { values } + pub(crate) fn verify_relation_outputs(&self, stage: &str) -> Result<(), EmitError> { + let relations = self + .instance_results + .iter() + .map(|instance| instance.relation) + .collect::>(); + let field_values = self.scalar_values(); + let field_vector_values = self.field_vector_values(); + let point_values = self.point_values(); + verifier_relation_outputs::verify_relation_outputs( + stage, + verifier_relation_outputs::RelationOutputVerification { + relation_output_values: &self.relation_output_values, + relation_output_eval_families: &self.relation_output_eval_families, + relation_output_product_families: &self.relation_output_product_families, + relation_output_function_families: &self.relation_output_function_families, + relation_outputs: &self.relation_outputs, + relations: &relations, + field_values: &field_values, + field_vector_values: &field_vector_values, + point_values: &point_values, + }, + ) + } + pub(crate) fn opening_point_sources(&self) -> BTreeSet { let mut values = BTreeSet::new(); values.extend(self.drivers.iter().map(|driver| driver.symbol.clone())); diff --git a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs index 985c1152d9..2c0bb281f6 100644 --- a/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs +++ b/crates/bolt/src/protocols/jolt/verifier_relation_outputs.rs @@ -10,6 +10,7 @@ use crate::protocols::jolt::cpu_attrs::{ }; use crate::protocols::jolt::rust_target_plan::{ power_strided_weighted_sum_formula, structured_polynomial_scalar_formula, + JoltVerifierRelationKind, }; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointValueRef, @@ -301,27 +302,30 @@ pub struct RelationOutputFunctionFamilyPlan { #[derive(Clone, Debug, PartialEq, Eq)] pub struct RelationOutputPlan { - pub relation: String, + pub(crate) relation: JoltVerifierRelationKind, local_scalars: Vec, expected_output: VerifierScalarValueRef, } impl RelationOutputPlan { - pub fn new(relation: impl Into, expected_output: impl Into) -> Self { + pub(crate) fn new( + relation: JoltVerifierRelationKind, + expected_output: impl Into, + ) -> Self { Self { - relation: relation.into(), + relation, local_scalars: Vec::new(), expected_output: VerifierScalarValueRef::new(expected_output), } } pub(crate) fn with_local_scalars( - relation: impl Into, + relation: JoltVerifierRelationKind, local_scalars: impl IntoIterator, expected_output: impl Into, ) -> Self { Self { - relation: relation.into(), + relation, local_scalars: local_scalars .into_iter() .map(|symbol| { @@ -346,6 +350,14 @@ impl RelationOutputPlan { pub fn expected_output_symbol(&self) -> &str { self.expected_output.symbol() } + + pub fn relation_symbol(&self) -> &'static str { + self.relation.cpu_symbol() + } + + pub(crate) fn relation(&self) -> JoltVerifierRelationKind { + self.relation + } } #[derive(Clone, Debug, PartialEq, Eq)] @@ -1156,10 +1168,9 @@ where claim.relation ))); } - Ok(RelationOutputPlan::new( - claim.relation, - claim.expected_output, - )) + let relation = JoltVerifierRelationKind::from_cpu_attr(&claim.relation) + .map_err(|error| EmitError::new(error.to_string()))?; + Ok(RelationOutputPlan::new(relation, claim.expected_output)) }) .collect() } @@ -1364,7 +1375,7 @@ pub struct RelationOutputVerification<'a> { pub relation_output_product_families: &'a [RelationOutputProductFamilyPlan], pub relation_output_function_families: &'a [RelationOutputFunctionFamilyPlan], pub relation_outputs: &'a [RelationOutputPlan], - pub relations: &'a BTreeSet, + pub relations: &'a BTreeSet, pub field_values: &'a VerifierScalarValueSet, pub field_vector_values: &'a VerifierFieldVectorValueSet, pub point_values: &'a VerifierPointValueSet, @@ -1526,21 +1537,23 @@ pub fn verify_relation_outputs( if !relations.contains(&claim.relation) { return Err(EmitError::new(format!( "{stage} relation output references missing relation @{}", - claim.relation + claim.relation.cpu_symbol() ))); } let expected_output = claim.expected_output_symbol(); if !field_values.contains_ref(&claim.expected_output) { return Err(EmitError::new(format!( "{stage} relation output for @{} uses missing expected output @{}", - claim.relation, expected_output + claim.relation.cpu_symbol(), + expected_output ))); } for local_scalar in &claim.local_scalars { if !field_values.contains_plan(local_scalar) { return Err(EmitError::new(format!( "{stage} relation output for @{} references missing local scalar @{}", - claim.relation, local_scalar.symbol + claim.relation.cpu_symbol(), + local_scalar.symbol ))); } } @@ -1614,6 +1627,7 @@ mod tests { use std::collections::BTreeSet; use crate::emit::rust::EmitError; + use crate::protocols::jolt::rust_target_plan::JoltVerifierRelationKind; use crate::protocols::jolt::verifier_values::{ VerifierFieldVectorValueRef, VerifierFieldVectorValueSet, VerifierPointValueKind, VerifierPointValueRef, VerifierPointValueSet, VerifierScalarValueKind, @@ -1970,9 +1984,9 @@ mod tests { field_values.insert("claim", VerifierScalarValueKind::FieldExpr); let field_vector_values = VerifierFieldVectorValueSet::default(); let point_values = VerifierPointValueSet::default(); - let relations = BTreeSet::from(["relation".to_owned()]); + let relations = BTreeSet::from([JoltVerifierRelationKind::Stage3Batched]); let relation_outputs = [RelationOutputPlan::with_local_scalars( - "relation", + JoltVerifierRelationKind::Stage3Batched, ["local.scalar".to_owned()], "claim", )]; @@ -2000,7 +2014,7 @@ mod tests { }; assert!(error.to_string().contains( - "stage relation output for @relation references missing local scalar @local.scalar" + "stage relation output for @jolt.stage3.batched references missing local scalar @local.scalar" )); Ok(()) } @@ -2106,9 +2120,9 @@ mod tests { field_values.insert("local.scalar", VerifierScalarValueKind::FieldExpr); let field_vector_values = VerifierFieldVectorValueSet::default(); let point_values = VerifierPointValueSet::default(); - let relations = BTreeSet::from(["relation".to_owned()]); + let relations = BTreeSet::from([JoltVerifierRelationKind::Stage3Batched]); let relation_outputs = [RelationOutputPlan::with_local_scalars( - "relation", + JoltVerifierRelationKind::Stage3Batched, ["local.scalar".to_owned()], "claim", )]; @@ -2136,7 +2150,7 @@ mod tests { }; assert!(error.to_string().contains( - "stage relation output for @relation references missing local scalar @local.scalar" + "stage relation output for @jolt.stage3.batched references missing local scalar @local.scalar" )); Ok(()) } diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index e9b8b59282..f6cd0ab3ad 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -795,7 +795,7 @@ macro_rules! define_stage_adapter_impl { .relation_outputs .iter() .map(|plan| $module::$relation_output { - relation: super::generated_relation_kind(&plan.relation), + relation: super::generated_relation_kind(plan.relation_symbol()), local_scalars: super::leak_str_iter(plan.local_scalar_symbols()), expected_output: super::leak_str(plan.expected_output_symbol()), }) From 6786a5df0e0ba76a632ea0012e209474ddcec1ea Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 11:39:49 -0600 Subject: [PATCH 165/171] refactor(verifier): validate sumcheck flow in plan Move verifier-mode Stage 3-7 sumcheck batch and driver consistency checks onto VerifierStagePlan. Stage-local verifier validation now keeps only role-shape checks, while prover kernel validation remains stage-owned. --- crates/bolt/GOAL.md | 6 +- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 11 +-- .../src/protocols/jolt/emit/rust/stage3.rs | 30 ++------ .../src/protocols/jolt/emit/rust/stage4.rs | 30 ++------ .../src/protocols/jolt/emit/rust/stage5.rs | 30 ++------ .../src/protocols/jolt/emit/rust/stage6.rs | 30 ++------ .../src/protocols/jolt/emit/rust/stage7.rs | 30 ++------ .../bolt/src/protocols/jolt/verifier_plan.rs | 75 ++++++++++++++++++- 8 files changed, 107 insertions(+), 135 deletions(-) diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index fa0838256c..af1a71f44c 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -67,9 +67,9 @@ Current S2.75-S5 implementation status: CPU-to-Rust planning boundary is now explicit: `VerifierStagePlan` is built through named planning functions for program steps, transcript flow, sumchecks, value/relation outputs, opening flow, and Stage 5/6 relation-local - inputs. Relation-output validation is now owned by `VerifierStagePlan`. - Remaining S2.75 work is concentrated in target validation still owned by - emitters. + inputs. Relation-output and verifier sumcheck-flow validation are now owned + by `VerifierStagePlan`. Remaining S2.75 work is concentrated in target + validation still owned by emitters. - Performance evidence remains a live completion gate. The SHA2-chain perf oracles must be rerun for the interpreter-heavy slices before this goal is closed. diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 171978896d..d6ffac8195 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -577,11 +577,12 @@ boundaries explicit as named planning functions: `plan_opening_flow`. Stage 5/6 relation-local input plans are also now produced through this shared -planning boundary, and relation-output validation now runs from -`VerifierStagePlan` instead of repeated stage-local string sets. The remaining -S2.75 work is narrower: continue moving target validation toward typed planning -outputs instead of stage-local emitter checks, and avoid putting any new -verifier semantics directly in Rust template logic. +planning boundary. Relation-output validation and verifier-mode sumcheck +batch/driver consistency checks now run from `VerifierStagePlan` instead of +repeated stage-local string sets and batch maps. The remaining S2.75 work is +narrower: continue moving target validation toward typed planning outputs +instead of stage-local emitter checks, and avoid putting any new verifier +semantics directly in Rust template logic. --- diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index c17d676653..398ff27a83 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -312,13 +312,16 @@ impl Stage3CpuProgram { require_supported_symbol("transcript", &self.params.transcript, "blake2b_transcript")?; self.verify_transcript_squeezes()?; self.verify_field_flow()?; - self.verify_claim_batches()?; match self.role { Role::Prover => { + self.verify_claim_batches()?; self.verify_kernel_definitions()?; self.verify_prover_driver_bindings()?; } - Role::Verifier => self.verify_verifier_driver_bindings()?, + Role::Verifier => { + self.verifier_plan()?.verify_sumcheck_flow("stage3")?; + self.verify_verifier_driver_bindings()?; + } } if self.role == Role::Verifier { self.verify_relation_outputs()?; @@ -560,11 +563,6 @@ impl Stage3CpuProgram { "verifier stage3 program must not contain kernels", )); } - let batches: BTreeMap<_, _> = self - .batches - .iter() - .map(|batch| (batch.symbol.as_str(), batch)) - .collect(); for claim in &self.claims { if claim.kernel.is_some() || claim.relation.is_none() { return Err(EmitError::new(format!( @@ -580,24 +578,6 @@ impl Stage3CpuProgram { driver.symbol ))); } - let batch = batches.get(driver.batch.as_str()).ok_or_else(|| { - EmitError::new(format!( - "sumcheck driver @{} references missing batch @{}", - driver.symbol, driver.batch - )) - })?; - verify_count( - "sumcheck driver round_schedule", - &driver.symbol, - driver.num_rounds, - driver.round_schedule.iter().sum(), - )?; - if driver.round_schedule != batch.round_schedule { - return Err(EmitError::new(format!( - "sumcheck driver @{} round_schedule differs from batch @{}", - driver.symbol, batch.symbol - ))); - } } Ok(()) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 9688af4b51..dfc2658b68 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -327,13 +327,16 @@ impl Stage4CpuProgram { require_supported_symbol("transcript", &self.params.transcript, "blake2b_transcript")?; self.verify_transcript_steps()?; self.verify_field_flow()?; - self.verify_claim_batches()?; match self.role { Role::Prover => { + self.verify_claim_batches()?; self.verify_kernel_definitions()?; self.verify_prover_driver_bindings()?; } - Role::Verifier => self.verify_verifier_driver_bindings()?, + Role::Verifier => { + self.verifier_plan()?.verify_sumcheck_flow("stage4")?; + self.verify_verifier_driver_bindings()?; + } } if self.role == Role::Verifier { self.verify_relation_outputs()?; @@ -582,11 +585,6 @@ impl Stage4CpuProgram { "verifier stage4 program must not contain kernels", )); } - let batches: BTreeMap<_, _> = self - .batches - .iter() - .map(|batch| (batch.symbol.as_str(), batch)) - .collect(); for claim in &self.claims { if claim.kernel.is_some() || claim.relation.is_none() { return Err(EmitError::new(format!( @@ -602,24 +600,6 @@ impl Stage4CpuProgram { driver.symbol ))); } - let batch = batches.get(driver.batch.as_str()).ok_or_else(|| { - EmitError::new(format!( - "sumcheck driver @{} references missing batch @{}", - driver.symbol, driver.batch - )) - })?; - verify_count( - "sumcheck driver round_schedule", - &driver.symbol, - driver.num_rounds, - driver.round_schedule.iter().sum(), - )?; - if driver.round_schedule != batch.round_schedule { - return Err(EmitError::new(format!( - "sumcheck driver @{} round_schedule differs from batch @{}", - driver.symbol, batch.symbol - ))); - } } Ok(()) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index cd805762ba..12dc4e2e75 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -401,13 +401,16 @@ impl Stage5CpuProgram { require_supported_symbol("transcript", &self.params.transcript, "blake2b_transcript")?; self.verify_transcript_steps()?; self.verify_field_flow()?; - self.verify_claim_batches()?; match self.role { Role::Prover => { + self.verify_claim_batches()?; self.verify_kernel_definitions()?; self.verify_prover_driver_bindings()?; } - Role::Verifier => self.verify_verifier_driver_bindings()?, + Role::Verifier => { + self.verifier_plan()?.verify_sumcheck_flow("stage5")?; + self.verify_verifier_driver_bindings()?; + } } if self.role == Role::Verifier { self.verify_relation_outputs()?; @@ -681,11 +684,6 @@ impl Stage5CpuProgram { "verifier stage5 program must not contain kernels", )); } - let batches: BTreeMap<_, _> = self - .batches - .iter() - .map(|batch| (batch.symbol.as_str(), batch)) - .collect(); for claim in &self.claims { if claim.kernel.is_some() || claim.relation.is_none() { return Err(EmitError::new(format!( @@ -701,24 +699,6 @@ impl Stage5CpuProgram { driver.symbol ))); } - let batch = batches.get(driver.batch.as_str()).ok_or_else(|| { - EmitError::new(format!( - "sumcheck driver @{} references missing batch @{}", - driver.symbol, driver.batch - )) - })?; - verify_count( - "sumcheck driver round_schedule", - &driver.symbol, - driver.num_rounds, - driver.round_schedule.iter().sum(), - )?; - if driver.round_schedule != batch.round_schedule { - return Err(EmitError::new(format!( - "sumcheck driver @{} round_schedule differs from batch @{}", - driver.symbol, batch.symbol - ))); - } } Ok(()) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index bd36c3c080..e21317a41d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -421,13 +421,16 @@ impl Stage6CpuProgram { require_supported_symbol("transcript", &self.params.transcript, "blake2b_transcript")?; self.verify_transcript_steps()?; self.verify_field_flow()?; - self.verify_claim_batches()?; match self.role { Role::Prover => { + self.verify_claim_batches()?; self.verify_kernel_definitions()?; self.verify_prover_driver_bindings()?; } - Role::Verifier => self.verify_verifier_driver_bindings()?, + Role::Verifier => { + self.verifier_plan()?.verify_sumcheck_flow("stage6")?; + self.verify_verifier_driver_bindings()?; + } } if self.role == Role::Verifier { self.verify_relation_outputs()?; @@ -695,11 +698,6 @@ impl Stage6CpuProgram { "verifier stage6 program must not contain kernels", )); } - let batches: BTreeMap<_, _> = self - .batches - .iter() - .map(|batch| (batch.symbol.as_str(), batch)) - .collect(); for claim in &self.claims { if claim.kernel.is_some() || claim.relation.is_none() { return Err(EmitError::new(format!( @@ -715,24 +713,6 @@ impl Stage6CpuProgram { driver.symbol ))); } - let batch = batches.get(driver.batch.as_str()).ok_or_else(|| { - EmitError::new(format!( - "sumcheck driver @{} references missing batch @{}", - driver.symbol, driver.batch - )) - })?; - verify_count( - "sumcheck driver round_schedule", - &driver.symbol, - driver.num_rounds, - driver.round_schedule.iter().sum(), - )?; - if driver.round_schedule != batch.round_schedule { - return Err(EmitError::new(format!( - "sumcheck driver @{} round_schedule differs from batch @{}", - driver.symbol, batch.symbol - ))); - } } Ok(()) } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 7a26dccffe..ae4c41fbcd 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -530,13 +530,16 @@ impl Stage7CpuProgram { require_supported_symbol("transcript", &self.params.transcript, "blake2b_transcript")?; self.verify_transcript_steps()?; self.verify_field_flow()?; - self.verify_claim_batches()?; match self.role { Role::Prover => { + self.verify_claim_batches()?; self.verify_kernel_definitions()?; self.verify_prover_driver_bindings()?; } - Role::Verifier => self.verify_verifier_driver_bindings()?, + Role::Verifier => { + self.verifier_plan()?.verify_sumcheck_flow("stage7")?; + self.verify_verifier_driver_bindings()?; + } } if self.role == Role::Verifier { self.verify_relation_outputs()?; @@ -798,11 +801,6 @@ impl Stage7CpuProgram { "verifier stage7 program must not contain kernels", )); } - let batches: BTreeMap<_, _> = self - .batches - .iter() - .map(|batch| (batch.symbol.as_str(), batch)) - .collect(); for claim in &self.claims { if claim.kernel.is_some() || claim.relation.is_none() { return Err(EmitError::new(format!( @@ -818,24 +816,6 @@ impl Stage7CpuProgram { driver.symbol ))); } - let batch = batches.get(driver.batch.as_str()).ok_or_else(|| { - EmitError::new(format!( - "sumcheck driver @{} references missing batch @{}", - driver.symbol, driver.batch - )) - })?; - verify_count( - "sumcheck driver round_schedule", - &driver.symbol, - driver.num_rounds, - driver.round_schedule.iter().sum(), - )?; - if driver.round_schedule != batch.round_schedule { - return Err(EmitError::new(format!( - "sumcheck driver @{} round_schedule differs from batch @{}", - driver.symbol, batch.symbol - ))); - } } Ok(()) } diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index 964cf3a3bb..dfb3121f91 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -1,4 +1,4 @@ -use std::collections::BTreeSet; +use std::collections::{BTreeMap, BTreeSet}; use std::fmt::Write as _; use crate::emit::rust::EmitError; @@ -609,6 +609,64 @@ impl VerifierStagePlan { values } + pub(crate) fn verify_sumcheck_flow(&self, stage: &str) -> Result<(), EmitError> { + let claims = self + .claims + .iter() + .map(|claim| claim.symbol.as_str()) + .collect::>(); + for batch in &self.batches { + verify_plan_count( + "sumcheck batch", + &batch.symbol, + batch.count, + batch.claim_operands.len(), + )?; + for claim in &batch.claim_operands { + if !claims.contains(claim.as_str()) { + return Err(EmitError::new(format!( + "{stage} sumcheck batch @{} references missing claim @{claim}", + batch.symbol + ))); + } + } + } + let batches: BTreeMap<_, _> = self + .batches + .iter() + .map(|batch| (batch.symbol.as_str(), batch)) + .collect(); + for driver in &self.drivers { + let batch = batches.get(driver.batch.as_str()).ok_or_else(|| { + EmitError::new(format!( + "{stage} sumcheck driver @{} references missing batch @{}", + driver.symbol, driver.batch + )) + })?; + verify_plan_count( + "sumcheck driver round_schedule", + &driver.symbol, + driver.num_rounds, + driver.round_schedule.iter().sum(), + )?; + if driver.round_schedule != batch.round_schedule { + return Err(EmitError::new(format!( + "{stage} sumcheck driver @{} round_schedule differs from batch @{}", + driver.symbol, batch.symbol + ))); + } + } + for instance in &self.instance_results { + if !claims.contains(instance.claim.as_str()) { + return Err(EmitError::new(format!( + "{stage} sumcheck instance result @{} references missing claim @{}", + instance.symbol, instance.claim + ))); + } + } + Ok(()) + } + pub(crate) fn verify_relation_outputs(&self, stage: &str) -> Result<(), EmitError> { let relations = self .instance_results @@ -2439,12 +2497,25 @@ fn verify_plan_operand_count( symbol: &str, expected: usize, actual: usize, +) -> Result<(), EmitError> { + verify_plan_count(kind, symbol, expected, actual).map_err(|_| { + EmitError::new(format!( + "{kind} @{symbol} operand count mismatch: expected {expected}, got {actual}" + )) + }) +} + +fn verify_plan_count( + kind: &str, + symbol: &str, + expected: usize, + actual: usize, ) -> Result<(), EmitError> { if expected == actual { Ok(()) } else { Err(EmitError::new(format!( - "{kind} @{symbol} operand count mismatch: expected {expected}, got {actual}" + "{kind} @{symbol} count mismatch: expected {expected}, got {actual}" ))) } } From 4f020bb7ffb38c18bb07bba61a0fa336c6b38819 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 11:45:34 -0600 Subject: [PATCH 166/171] refactor(verifier): validate openings in plan Move verifier-mode Stage 3-7 opening-flow validation onto VerifierStagePlan. Prover input-opening checks stay stage-local because verifier runtime claim rows do not carry those fields. --- crates/bolt/GOAL.md | 6 +- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 12 +- .../src/protocols/jolt/emit/rust/stage3.rs | 40 +++--- .../src/protocols/jolt/emit/rust/stage4.rs | 40 +++--- .../src/protocols/jolt/emit/rust/stage5.rs | 40 +++--- .../src/protocols/jolt/emit/rust/stage6.rs | 42 +++--- .../src/protocols/jolt/emit/rust/stage7.rs | 42 +++--- .../bolt/src/protocols/jolt/verifier_plan.rs | 120 ++++++++++++++++++ 8 files changed, 218 insertions(+), 124 deletions(-) diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index af1a71f44c..72be0a0a61 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -67,9 +67,9 @@ Current S2.75-S5 implementation status: CPU-to-Rust planning boundary is now explicit: `VerifierStagePlan` is built through named planning functions for program steps, transcript flow, sumchecks, value/relation outputs, opening flow, and Stage 5/6 relation-local - inputs. Relation-output and verifier sumcheck-flow validation are now owned - by `VerifierStagePlan`. Remaining S2.75 work is concentrated in target - validation still owned by emitters. + inputs. Relation-output, verifier sumcheck-flow, and verifier opening-flow + validation are now owned by `VerifierStagePlan`. Remaining S2.75 work is + concentrated in target validation still owned by emitters. - Performance evidence remains a live completion gate. The SHA2-chain perf oracles must be rerun for the interpreter-heavy slices before this goal is closed. diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index d6ffac8195..8dbeaae735 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -579,10 +579,14 @@ boundaries explicit as named planning functions: Stage 5/6 relation-local input plans are also now produced through this shared planning boundary. Relation-output validation and verifier-mode sumcheck batch/driver consistency checks now run from `VerifierStagePlan` instead of -repeated stage-local string sets and batch maps. The remaining S2.75 work is -narrower: continue moving target validation toward typed planning outputs -instead of stage-local emitter checks, and avoid putting any new verifier -semantics directly in Rust template logic. +repeated stage-local string sets and batch maps. Verifier-mode opening-flow +checks for point sources, opening equalities, opening claims, sumcheck eval +sources, and opening batches also run from `VerifierStagePlan`; prover +`input_openings` checks remain stage-local because verifier runtime claim rows +do not carry those fields. The remaining S2.75 work is narrower: continue +moving target validation toward typed planning outputs instead of stage-local +emitter checks, and avoid putting any new verifier semantics directly in Rust +template logic. --- diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 398ff27a83..5ce1a2b656 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -587,24 +587,22 @@ impl Stage3CpuProgram { } fn verify_opening_flow(&self) -> Result<(), EmitError> { - let point_sources = if self.role == Role::Verifier { - self.verifier_plan()?.opening_point_sources() - } else { - let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); - point_sources.extend(symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - )); - point_sources.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_sources.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); - point_sources - }; + if self.role == Role::Verifier { + return self.verifier_plan()?.verify_opening_flow("stage3"); + } + let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); + point_sources.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + point_sources.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_sources.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); for slice in &self.point_slices { if !point_sources.contains(&slice.input) { return Err(EmitError::new(format!( @@ -623,11 +621,7 @@ impl Stage3CpuProgram { } } } - let eval_sources = if self.role == Role::Verifier { - self.verifier_plan()?.scalar_value_sources() - } else { - self.cpu_field_value_sources() - }; + let eval_sources = self.cpu_field_value_sources(); let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( self.opening_claims.iter().map(|claim| &claim.symbol), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index dfc2658b68..1dbf3de714 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -609,24 +609,22 @@ impl Stage4CpuProgram { } fn verify_opening_flow(&self) -> Result<(), EmitError> { - let point_sources = if self.role == Role::Verifier { - self.verifier_plan()?.opening_point_sources() - } else { - let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); - point_sources.extend(symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - )); - point_sources.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_sources.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); - point_sources - }; + if self.role == Role::Verifier { + return self.verifier_plan()?.verify_opening_flow("stage4"); + } + let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); + point_sources.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + point_sources.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_sources.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); for slice in &self.point_slices { if !point_sources.contains(&slice.input) { return Err(EmitError::new(format!( @@ -645,11 +643,7 @@ impl Stage4CpuProgram { } } } - let eval_sources = if self.role == Role::Verifier { - self.verifier_plan()?.scalar_value_sources() - } else { - self.cpu_field_value_sources() - }; + let eval_sources = self.cpu_field_value_sources(); let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( self.opening_claims.iter().map(|claim| &claim.symbol), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index 12dc4e2e75..aca4bd9383 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -708,24 +708,22 @@ impl Stage5CpuProgram { } fn verify_opening_flow(&self) -> Result<(), EmitError> { - let point_sources = if self.role == Role::Verifier { - self.verifier_plan()?.opening_point_sources() - } else { - let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); - point_sources.extend(symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - )); - point_sources.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_sources.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); - point_sources - }; + if self.role == Role::Verifier { + return self.verifier_plan()?.verify_opening_flow("stage5"); + } + let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); + point_sources.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + point_sources.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_sources.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); for slice in &self.point_slices { if !point_sources.contains(&slice.input) { return Err(EmitError::new(format!( @@ -744,11 +742,7 @@ impl Stage5CpuProgram { } } } - let eval_sources = if self.role == Role::Verifier { - self.verifier_plan()?.scalar_value_sources() - } else { - self.cpu_field_value_sources() - }; + let eval_sources = self.cpu_field_value_sources(); let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( self.opening_claims.iter().map(|claim| &claim.symbol), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index e21317a41d..a2045fc14b 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -722,25 +722,23 @@ impl Stage6CpuProgram { } fn verify_opening_flow(&self) -> Result<(), EmitError> { - let point_sources = if self.role == Role::Verifier { - self.verifier_plan()?.opening_point_sources() - } else { - let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); - point_sources.extend(symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - )); - point_sources.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_sources.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); - point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_sources.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); - point_sources - }; + if self.role == Role::Verifier { + return self.verifier_plan()?.verify_opening_flow("stage6"); + } + let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); + point_sources.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + point_sources.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_sources.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); + point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_sources.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); for zero in &self.point_zeros { require_supported_symbol("point zero field", &zero.field, "bn254_fr")?; } @@ -762,11 +760,7 @@ impl Stage6CpuProgram { } } } - let eval_sources = if self.role == Role::Verifier { - self.verifier_plan()?.scalar_value_sources() - } else { - self.cpu_field_value_sources() - }; + let eval_sources = self.cpu_field_value_sources(); let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( self.opening_claims.iter().map(|claim| &claim.symbol), diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index ae4c41fbcd..6ab8c8d271 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -825,25 +825,23 @@ impl Stage7CpuProgram { } fn verify_opening_flow(&self) -> Result<(), EmitError> { - let point_sources = if self.role == Role::Verifier { - self.verifier_plan()?.opening_point_sources() - } else { - let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); - point_sources.extend(symbols( - self.instance_results - .iter() - .map(|instance| &instance.symbol), - )); - point_sources.extend(symbols( - self.opening_inputs.iter().map(|input| &input.symbol), - )); - point_sources.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); - point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); - point_sources.extend(symbols( - self.point_concats.iter().map(|concat| &concat.symbol), - )); - point_sources - }; + if self.role == Role::Verifier { + return self.verifier_plan()?.verify_opening_flow("stage7"); + } + let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); + point_sources.extend(symbols( + self.instance_results + .iter() + .map(|instance| &instance.symbol), + )); + point_sources.extend(symbols( + self.opening_inputs.iter().map(|input| &input.symbol), + )); + point_sources.extend(symbols(self.point_zeros.iter().map(|zero| &zero.symbol))); + point_sources.extend(symbols(self.point_slices.iter().map(|slice| &slice.symbol))); + point_sources.extend(symbols( + self.point_concats.iter().map(|concat| &concat.symbol), + )); for zero in &self.point_zeros { require_supported_symbol("point zero field", &zero.field, "bn254_fr")?; } @@ -865,11 +863,7 @@ impl Stage7CpuProgram { } } } - let eval_sources = if self.role == Role::Verifier { - self.verifier_plan()?.scalar_value_sources() - } else { - self.cpu_field_value_sources() - }; + let eval_sources = self.cpu_field_value_sources(); let mut opening_sources = symbols(self.opening_inputs.iter().map(|input| &input.symbol)); opening_sources.extend(symbols( self.opening_claims.iter().map(|claim| &claim.symbol), diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index dfb3121f91..a1b54b4cb8 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -692,6 +692,126 @@ impl VerifierStagePlan { ) } + pub(crate) fn verify_opening_flow(&self, stage: &str) -> Result<(), EmitError> { + let point_sources = self.opening_point_sources(); + for expr in &self.point_exprs { + if let VerifierPointExprKind::Zero { field, .. } = &expr.kind { + if field != "bn254_fr" { + return Err(EmitError::new(format!( + "{stage} point expr @{} has unsupported zero field `{field}`", + expr.symbol + ))); + } + } + for input in &expr.operands { + if !point_sources.contains(input) { + return Err(EmitError::new(format!( + "{stage} point expr @{} uses missing point source @{input}", + expr.symbol + ))); + } + } + } + + let mut opening_sources = self + .opening_inputs + .iter() + .map(|input| input.symbol.as_str()) + .collect::>(); + opening_sources.extend( + self.opening_claims + .iter() + .map(|claim| claim.symbol.as_str()), + ); + for equality in &self.opening_equalities { + if !opening_sources.contains(equality.lhs.as_str()) { + return Err(EmitError::new(format!( + "{stage} opening equality @{} uses missing lhs opening @{}", + equality.symbol, equality.lhs + ))); + } + if !opening_sources.contains(equality.rhs.as_str()) { + return Err(EmitError::new(format!( + "{stage} opening equality @{} uses missing rhs opening @{}", + equality.symbol, equality.rhs + ))); + } + } + + let drivers = self + .drivers + .iter() + .map(|driver| driver.symbol.as_str()) + .collect::>(); + for instance in &self.instance_results { + if !drivers.contains(instance.source.as_str()) { + return Err(EmitError::new(format!( + "{stage} sumcheck instance result @{} references missing driver @{}", + instance.symbol, instance.source + ))); + } + } + for eval in &self.sumcheck_evals { + if !drivers.contains(eval.source.as_str()) { + return Err(EmitError::new(format!( + "{stage} sumcheck eval @{} references missing driver @{}", + eval.symbol, eval.source + ))); + } + } + + let eval_sources = self.scalar_value_sources(); + for claim in &self.opening_claims { + if !point_sources.contains(&claim.point_source) { + return Err(EmitError::new(format!( + "{stage} opening claim @{} uses missing point source @{}", + claim.symbol, claim.point_source + ))); + } + if !eval_sources.contains(&claim.eval_source) { + return Err(EmitError::new(format!( + "{stage} opening claim @{} uses missing eval source @{}", + claim.symbol, claim.eval_source + ))); + } + } + + let openings = self + .opening_claims + .iter() + .map(|claim| claim.symbol.as_str()) + .collect::>(); + for batch in &self.opening_batches { + verify_plan_count( + "opening batch", + &batch.symbol, + batch.count, + batch.ordered_claims.len(), + )?; + verify_plan_count( + "opening batch operands", + &batch.symbol, + batch.count, + batch.claim_operands.len(), + )?; + if batch.ordered_claims != batch.claim_operands { + return Err(EmitError::new(format!( + "{stage} opening batch @{} operand order does not match ordered_claims", + batch.symbol + ))); + } + for claim in &batch.ordered_claims { + if !openings.contains(claim.as_str()) { + return Err(EmitError::new(format!( + "{stage} opening batch @{} references missing opening @{claim}", + batch.symbol + ))); + } + } + } + Ok(()) + } + pub(crate) fn opening_point_sources(&self) -> BTreeSet { let mut values = BTreeSet::new(); values.extend(self.drivers.iter().map(|driver| driver.symbol.clone())); From 372303eb7fbf46ba7d8fb2f47c1b0bfabf0de26f Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 11:52:08 -0600 Subject: [PATCH 167/171] docs(verifier): record perf evidence Record current SHA2-chain perf oracle results for the verifier-program refactor completion gate. The 2^20 oracle is green on current tip but remains a fragile-margin risk. --- crates/bolt/GOAL.md | 20 +++++++++++++++++++ crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 8 ++++++++ 2 files changed, 28 insertions(+) diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index 72be0a0a61..111f24f2f4 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -575,6 +575,26 @@ repeatable verifier-time regressions are fixed or explicitly approved perf thresholds are not loosened to land readability refactors ``` +Current perf evidence from May 16, 2026 on `quang/bolt-stack`: + +```text +2^16 SHA2-chain oracle, 1 sample: passed + verify_ms ratio: 1.090x + prove_ms ratio: 0.856x + +2^20 SHA2-chain oracle, 1 sample: passed + verify_ms ratio: 1.124x + prove_ms ratio: 1.298x against 1.300x gate + +2^20 SHA2-chain oracle, 3 samples: passed + verify_ms ratio: 0.987x + prove_ms mean ratio: 1.329x, 95% CI [1.284x, 1.373x] +``` + +The previous hard perf blocker has moved to a fragile-margin risk: current +oracles are green, but the 2^20 prover-time ratio remains close enough to the +threshold that future completion audits should rerun it. + Semantic gates: ```bash diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 8dbeaae735..a9682089be 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -1205,6 +1205,14 @@ fix it or explicitly document why the readability/security gain is worth the cost. Do not loosen perf thresholds to make a refactor pass. The existing S2/S2.5 progress should keep its captured baselines as reference data. +Current evidence from May 16, 2026 on `quang/bolt-stack` is green but close: +the 2^16 oracle passed with verifier ratio `1.090x` and prove ratio `0.856x`; +the 2^20 one-sample oracle passed with verifier ratio `1.124x` and prove ratio +`1.298x` against the `1.300x` prove gate; the 2^20 three-sample oracle passed +with verifier ratio `0.987x` and prove mean `1.329x`, 95% CI +`[1.284x, 1.373x]`. Treat this as a fragile-margin risk, not a reason to +loosen thresholds. + The expected trend is "no measurable verifier change," because the interpreter dispatches are straightforward and relation/value-graph evaluation happens a small fixed number of times per verification. Any accidental From ed72da6b482ecc30880ab75c4665c3be38d12e24 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 12:07:31 -0600 Subject: [PATCH 168/171] refactor(verifier): route stage2 through plan --- crates/bolt/GOAL.md | 16 +- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 15 +- .../src/protocols/jolt/emit/rust/stage2.rs | 324 ++++-------------- .../bolt/src/protocols/jolt/verifier_plan.rs | 11 + 4 files changed, 93 insertions(+), 273 deletions(-) diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index 111f24f2f4..573c73288f 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -63,13 +63,15 @@ Current S2.75-S5 implementation status: closed relation IDs, old eval-prefix reconstruction sites are gated at zero, and handwritten `expected_stage67_*` output helpers are gone from generated/runtime code. -- S2.75 remains the main incomplete architecture item, but its central - CPU-to-Rust planning boundary is now explicit: `VerifierStagePlan` is built - through named planning functions for program steps, transcript flow, - sumchecks, value/relation outputs, opening flow, and Stage 5/6 relation-local - inputs. Relation-output, verifier sumcheck-flow, and verifier opening-flow - validation are now owned by `VerifierStagePlan`. Remaining S2.75 work is - concentrated in target validation still owned by emitters. +- S2.75 is now largely implemented at the CPU-to-Rust planning boundary: + `VerifierStagePlan` is built through named planning functions for program + steps, transcript flow, sumchecks, value/relation outputs, opening flow, and + relation-local inputs. Stage 2-7 verifier sumcheck-flow, relation-output, and + opening-flow validation are owned by `VerifierStagePlan`; Stage 2 also uses + the shared CPU row types instead of local copies. Remaining S2.75 risk is no + longer the existence of the planning boundary, but the audit quality of the + handwritten Stage 2 relation-output formulas and any target validation still + tied to emitter-side checks. - Performance evidence remains a live completion gate. The SHA2-chain perf oracles must be rerun for the interpreter-heavy slices before this goal is closed. diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index a9682089be..6ebc77dfba 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -583,10 +583,17 @@ repeated stage-local string sets and batch maps. Verifier-mode opening-flow checks for point sources, opening equalities, opening claims, sumcheck eval sources, and opening batches also run from `VerifierStagePlan`; prover `input_openings` checks remain stage-local because verifier runtime claim rows -do not carry those fields. The remaining S2.75 work is narrower: continue -moving target validation toward typed planning outputs instead of stage-local -emitter checks, and avoid putting any new verifier semantics directly in Rust -template logic. +do not carry those fields. + +Stage 2 now shares the same compiler-side CPU row structs as Stage 3-7 and +builds a `VerifierStagePlan` for verifier programs. Its verifier sumcheck, +relation-output, and opening-flow checks run through the shared plan. The +remaining S2.75 risk is no longer that Stage 2 lacks the typed planning +boundary; it is that Stage 2 still contains a handwritten relation-output +formula table whose operands are validated through the existing field/scalar +flow checks. The next closeout step should be a completion audit that separates +true remaining architecture work from gates: semantic/tamper behavior, +host/zk e2e, and the fragile perf oracle. --- diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 3bbb6dc3f6..471c3783ee 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -7,17 +7,43 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::rust_target_plan::{ - structured_polynomial_scalar_formula, ClaimKind, FieldExprKind, JoltVerifierRelationKind, - ProgramStepKind, RustTargetPlanError, ScalarExprKind, TranscriptSqueezeKind, + structured_polynomial_scalar_formula, JoltVerifierRelationKind, RustTargetPlanError, + ScalarExprKind, }; -use crate::protocols::jolt::{verifier_plan, verifier_relation_outputs, verifier_values}; +use crate::protocols::jolt::verifier_opening_rows; +use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; +use crate::protocols::jolt::verifier_point_rows; +use crate::protocols::jolt::verifier_program_rows; +use crate::protocols::jolt::verifier_relation_outputs::{ + self, StructuredPolynomialEvalPlan as Stage2StructuredPolynomialEvalPlan, +}; +use crate::protocols::jolt::verifier_sumcheck_rows; +use crate::protocols::jolt::verifier_value_rows; +use crate::protocols::jolt::verifier_values; use crate::schema::verify_cpu_schema; type Stage2RelationOutputPlan = verifier_relation_outputs::RelationOutputPlan; +type Stage2TranscriptSqueezePlan = verifier_program_rows::CpuTranscriptSqueezePlan; +type Stage2ProgramStepPlan = verifier_program_rows::CpuProgramStepPlan; +type Stage2OpeningInputPlan = verifier_program_rows::CpuOpeningInputPlan; +type Stage2FieldConstantPlan = verifier_value_rows::CpuFieldConstantPlan; +type Stage2FieldExprPlan = verifier_value_rows::CpuFieldExprPlan; +type Stage2ScalarExprPlan = verifier_value_rows::CpuScalarExprPlan; +type Stage2SumcheckClaimPlan = verifier_sumcheck_rows::CpuSumcheckClaimPlan; +type Stage2SumcheckBatchPlan = verifier_sumcheck_rows::CpuSumcheckBatchPlan; +type Stage2SumcheckDriverPlan = verifier_sumcheck_rows::CpuSumcheckDriverPlan; +type Stage2SumcheckInstanceResultPlan = verifier_sumcheck_rows::CpuSumcheckInstanceResultPlan; +type Stage2SumcheckEvalPlan = verifier_sumcheck_rows::CpuSumcheckEvalPlan; +type Stage2PointSlicePlan = verifier_point_rows::CpuPointSlicePlan; +type Stage2PointConcatPlan = verifier_point_rows::CpuPointConcatPlan; +type Stage2OpeningClaimPlan = verifier_opening_rows::CpuOpeningClaimPlan; +type Stage2OpeningClaimEqualityPlan = verifier_opening_rows::CpuOpeningClaimEqualityPlan; +type Stage2OpeningBatchPlan = verifier_opening_rows::CpuOpeningBatchPlan; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stage2CpuProgram { pub role: Role, + pub(crate) verifier_plan: Option, pub params: Stage2Params, pub steps: Vec, pub transcript_squeezes: Vec, @@ -35,7 +61,9 @@ pub struct Stage2CpuProgram { pub point_slices: Vec, pub point_concats: Vec, pub opening_claims: Vec, + pub opening_equalities: Vec, pub opening_batches: Vec, + pub relation_output_values: Vec, } #[derive(Clone, Debug, PartialEq, Eq)] @@ -54,56 +82,6 @@ pub struct Stage2KernelPlan { pub abi: String, } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2TranscriptSqueezePlan { - pub symbol: String, - pub label: String, - pub kind: String, - pub count: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2ProgramStepPlan { - pub kind: String, - pub symbol: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2OpeningInputPlan { - pub symbol: String, - pub source_stage: String, - pub source_claim: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2FieldConstantPlan { - pub symbol: String, - pub field: String, - pub value: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2FieldExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2ScalarExprPlan { - pub symbol: String, - pub kind: String, - pub formula: String, - pub operand_names: Vec, - pub operands: Vec, -} - #[derive(Clone, Debug, PartialEq, Eq)] struct Stage2RelationOutputRows { field_constants: Vec, @@ -453,147 +431,7 @@ fn stage2_relation_output_plans() -> Stage2RelationOutputRows { } } -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2SumcheckClaimPlan { - pub symbol: String, - pub stage: String, - pub domain: String, - pub num_rounds: usize, - pub degree: usize, - pub claim: String, - pub kernel: Option, - pub relation: Option, - pub claim_value: String, - pub input_openings: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2SumcheckBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, - pub claim_label: String, - pub round_label: String, - pub round_schedule: Vec, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2SumcheckDriverPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub kernel: Option, - pub relation: Option, - pub batch: String, - pub policy: String, - pub round_schedule: Vec, - pub claim_label: String, - pub round_label: String, - pub num_rounds: usize, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2SumcheckInstanceResultPlan { - pub symbol: String, - pub source: String, - pub claim: String, - pub relation: String, - pub index: usize, - pub point_arity: usize, - pub num_rounds: usize, - pub round_offset: usize, - pub point_order: String, - pub degree: usize, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2SumcheckEvalPlan { - pub symbol: String, - pub source: String, - pub name: String, - pub index: usize, - pub oracle: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2PointSlicePlan { - pub symbol: String, - pub source: String, - pub offset: usize, - pub length: usize, - pub input: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2PointConcatPlan { - pub symbol: String, - pub layout: String, - pub arity: usize, - pub inputs: Vec, -} - -impl verifier_plan::VerifierPointSliceSource for Stage2PointSlicePlan { - fn symbol(&self) -> &str { - &self.symbol - } - - fn offset(&self) -> usize { - self.offset - } - - fn length(&self) -> usize { - self.length - } - - fn input(&self) -> &str { - &self.input - } -} - -impl verifier_plan::VerifierPointConcatSource for Stage2PointConcatPlan { - fn symbol(&self) -> &str { - &self.symbol - } - - fn layout(&self) -> &str { - &self.layout - } - - fn arity(&self) -> usize { - self.arity - } - - fn inputs(&self) -> &[String] { - &self.inputs - } -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2OpeningClaimPlan { - pub symbol: String, - pub oracle: String, - pub domain: String, - pub point_arity: usize, - pub claim_kind: String, - pub point_source: String, - pub eval_source: String, -} - -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Stage2OpeningBatchPlan { - pub symbol: String, - pub stage: String, - pub proof_slot: String, - pub policy: String, - pub count: usize, - pub ordered_claims: Vec, - pub claim_operands: Vec, -} +verifier_plan::impl_verifier_plan_source_traits!(program = Stage2CpuProgram,); pub fn stage2_cpu_program(module: &BoltModule<'_, Cpu>) -> Result { verify_cpu_schema(module)?; @@ -630,7 +468,9 @@ impl Stage2CpuProgram { let mut point_slices = Vec::new(); let mut point_concats = Vec::new(); let mut opening_claims = Vec::new(); + let opening_equalities = Vec::new(); let mut opening_batches = Vec::new(); + let relation_output_values = Vec::new(); let mut operation = module.as_mlir_module().body().first_operation(); while let Some(op) = operation { @@ -886,7 +726,8 @@ impl Stage2CpuProgram { let role = module .role() .ok_or_else(|| EmitError::new("missing cpu party role"))?; - if role == Role::Verifier { + let is_verifier = role == Role::Verifier; + if is_verifier { let relation_output_rows = stage2_relation_output_plans(); field_constants.extend(relation_output_rows.field_constants); field_exprs.extend(relation_output_rows.field_exprs); @@ -894,9 +735,10 @@ impl Stage2CpuProgram { relation_outputs.extend(relation_output_rows.relation_outputs); } - Ok(Self { + let mut program = Self { params: params.ok_or_else(|| EmitError::new("missing cpu.params"))?, role, + verifier_plan: None, steps, transcript_squeezes, opening_inputs, @@ -913,8 +755,24 @@ impl Stage2CpuProgram { point_slices, point_concats, opening_claims, + opening_equalities, opening_batches, - }) + relation_output_values, + }; + if is_verifier { + program.verifier_plan = Some(program.plan_verifier()?); + } + Ok(program) + } + + fn plan_verifier(&self) -> Result { + verifier_plan::plan_verifier_stage_from_cpu_sources(self) + } + + fn verifier_plan(&self) -> Result<&VerifierStagePlan, EmitError> { + self.verifier_plan + .as_ref() + .ok_or_else(|| EmitError::new("missing stage2 verifier plan")) } fn verify_supported_target(&self) -> Result<(), EmitError> { @@ -930,8 +788,9 @@ impl Stage2CpuProgram { self.verify_prover_driver_bindings()?; } Role::Verifier => { + self.verifier_plan()?.verify_sumcheck_flow("stage2")?; self.verify_verifier_driver_bindings()?; - self.verify_verifier_rust_target()?; + self.verify_relation_outputs()?; } } self.verify_opening_flow() @@ -1260,11 +1119,6 @@ impl Stage2CpuProgram { "verifier stage2 program must not contain kernels", )); } - let batches: BTreeMap<_, _> = self - .batches - .iter() - .map(|batch| (batch.symbol.as_str(), batch)) - .collect(); for claim in &self.claims { if claim.kernel.is_some() || claim.relation.is_none() { return Err(EmitError::new(format!( @@ -1280,72 +1134,18 @@ impl Stage2CpuProgram { driver.symbol ))); } - let batch = batches.get(driver.batch.as_str()).ok_or_else(|| { - EmitError::new(format!( - "sumcheck driver @{} references missing batch @{}", - driver.symbol, driver.batch - )) - })?; - verify_count( - "sumcheck driver round_schedule", - &driver.symbol, - driver.num_rounds, - driver.round_schedule.iter().sum(), - )?; - if driver.round_schedule != batch.round_schedule { - return Err(EmitError::new(format!( - "sumcheck driver @{} round_schedule differs from batch @{}", - driver.symbol, batch.symbol - ))); - } } Ok(()) } - fn verify_verifier_rust_target(&self) -> Result<(), EmitError> { - for step in &self.steps { - let _ = ProgramStepKind::from_cpu_attr(&step.kind).map_err(rust_target_plan_error)?; - } - for squeeze in &self.transcript_squeezes { - let _ = TranscriptSqueezeKind::from_cpu_attr(&squeeze.kind) - .map_err(rust_target_plan_error)?; - } - for input in &self.opening_inputs { - let _ = ClaimKind::from_cpu_attr(&input.claim_kind).map_err(rust_target_plan_error)?; - } - for expr in &self.field_exprs { - let _ = FieldExprKind::from_cpu_attr(&expr.formula).map_err(rust_target_plan_error)?; - } - for expr in &self.scalar_exprs { - let _ = ScalarExprKind::from_cpu_attr(&expr.formula).map_err(rust_target_plan_error)?; - } - for claim in &self.claims { - let relation = claim - .relation - .as_deref() - .ok_or_else(|| missing_role_binding("verifier claim relation", &claim.symbol))?; - let _ = JoltVerifierRelationKind::from_cpu_attr(relation) - .map_err(rust_target_plan_error)?; - } - for driver in &self.drivers { - let relation = driver - .relation - .as_deref() - .ok_or_else(|| missing_role_binding("verifier driver relation", &driver.symbol))?; - let _ = JoltVerifierRelationKind::from_cpu_attr(relation) - .map_err(rust_target_plan_error)?; - } - for instance in &self.instance_results { - let _ = JoltVerifierRelationKind::from_cpu_attr(&instance.relation) - .map_err(rust_target_plan_error)?; - } - for claim in &self.opening_claims { - let _ = ClaimKind::from_cpu_attr(&claim.claim_kind).map_err(rust_target_plan_error)?; - } - Ok(()) + fn verify_relation_outputs(&self) -> Result<(), EmitError> { + self.verifier_plan()?.verify_relation_outputs("stage2") } fn verify_opening_flow(&self) -> Result<(), EmitError> { + if self.role == Role::Verifier { + return self.verifier_plan()?.verify_opening_flow("stage2"); + } let mut point_sources = symbols(self.drivers.iter().map(|driver| &driver.symbol)); point_sources.extend(symbols( self.instance_results diff --git a/crates/bolt/src/protocols/jolt/verifier_plan.rs b/crates/bolt/src/protocols/jolt/verifier_plan.rs index a1b54b4cb8..5bd58a3754 100644 --- a/crates/bolt/src/protocols/jolt/verifier_plan.rs +++ b/crates/bolt/src/protocols/jolt/verifier_plan.rs @@ -542,6 +542,17 @@ impl VerifierStagePlan { VerifierScalarValueKind::OutputFunctionFamily, ) })); + values.extend( + self.relation_outputs + .iter() + .flat_map(|output| output.local_scalar_symbols()) + .map(|symbol| { + VerifierScalarValuePlan::new( + symbol.clone(), + VerifierScalarValueKind::RelationOutputLocal, + ) + }), + ); values.extend(self.field_exprs.iter().map(|expr| { VerifierScalarValuePlan::new(&expr.symbol, VerifierScalarValueKind::FieldExpr) })); From bbfa8adf353f609c66b5225c843933e0cafe1a13 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 12:10:45 -0600 Subject: [PATCH 169/171] test(verifier): enable stage3 parity gate --- crates/jolt-equivalence/tests/bolt_commitment.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/crates/jolt-equivalence/tests/bolt_commitment.rs b/crates/jolt-equivalence/tests/bolt_commitment.rs index 21e0bc308e..8f6a4824f3 100644 --- a/crates/jolt-equivalence/tests/bolt_commitment.rs +++ b/crates/jolt-equivalence/tests/bolt_commitment.rs @@ -312,7 +312,6 @@ fn bolt_stage2_batched_real_muldiv_self_parity() { } #[test] -#[ignore = "Stage 5+ instruction-read-RAF parity needs the follow-up generated kernel rewrite"] fn bolt_stage3_batched_real_muldiv_self_parity() { let _ = assert_bolt_full_real_trace_self_parity(core_muldiv_commitment_fixture(), false); } From 5e692d57875c23b2a286a5b20504bf71362a119c Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sat, 16 May 2026 12:15:59 -0600 Subject: [PATCH 170/171] docs(verifier): refresh perf evidence --- crates/bolt/GOAL.md | 11 ++++++----- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 6 +++--- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index 573c73288f..87dafebc01 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -589,13 +589,14 @@ Current perf evidence from May 16, 2026 on `quang/bolt-stack`: prove_ms ratio: 1.298x against 1.300x gate 2^20 SHA2-chain oracle, 3 samples: passed - verify_ms ratio: 0.987x - prove_ms mean ratio: 1.329x, 95% CI [1.284x, 1.373x] + verify_ms ratio: 1.089x + prove_ms mean ratio: 1.168x, 95% CI [0.876x, 1.460x] ``` -The previous hard perf blocker has moved to a fragile-margin risk: current -oracles are green, but the 2^20 prover-time ratio remains close enough to the -threshold that future completion audits should rerun it. +The previous hard perf blocker has moved out of the immediate blocker column: +current oracles are green, and the latest 2^20 three-sample mean is below the +threshold. The confidence interval still crosses the threshold, so future +interpreter-heavy slices should continue to rerun it. Semantic gates: diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 6ebc77dfba..5e1cfdafee 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -1216,9 +1216,9 @@ Current evidence from May 16, 2026 on `quang/bolt-stack` is green but close: the 2^16 oracle passed with verifier ratio `1.090x` and prove ratio `0.856x`; the 2^20 one-sample oracle passed with verifier ratio `1.124x` and prove ratio `1.298x` against the `1.300x` prove gate; the 2^20 three-sample oracle passed -with verifier ratio `0.987x` and prove mean `1.329x`, 95% CI -`[1.284x, 1.373x]`. Treat this as a fragile-margin risk, not a reason to -loosen thresholds. +after the Stage 2 verifier-plan cutover with verifier ratio `1.089x` and prove +mean `1.168x`, 95% CI `[0.876x, 1.460x]`. Treat this as a green completion +gate with noisy margin, not a reason to loosen thresholds. The expected trend is "no measurable verifier change," because the interpreter dispatches are straightforward and relation/value-graph evaluation happens a From 45f367731d7177f2271f977815b0f264f9fb2750 Mon Sep 17 00:00:00 2001 From: Quang Dao Date: Sun, 17 May 2026 10:13:07 -0700 Subject: [PATCH 171/171] refactor(verifier): tighten typed plan cutover Remove Jolt-specific point-order variants from the generic verifier runtime and route relation-local normalization through Jolt stage code. Make sumcheck eval observation require explicit eval names, cut Stage 2 verifier expression emission over to VerifierStagePlan helpers, and add cleanup gates for the runtime boundary and docs. --- crates/bolt-verifier-runtime/src/lib.rs | 62 ++++++++++++++---- crates/bolt/GOAL.md | 31 ++++----- crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md | 24 +++---- .../protocols/jolt/emit/rust/plan_tokens.rs | 18 ----- .../src/protocols/jolt/emit/rust/stage2.rs | 59 ++++------------- .../src/protocols/jolt/emit/rust/stage3.rs | 4 +- .../src/protocols/jolt/emit/rust/stage4.rs | 14 ++-- .../src/protocols/jolt/emit/rust/stage5.rs | 14 ++-- .../src/protocols/jolt/emit/rust/stage6.rs | 15 +++-- .../src/protocols/jolt/emit/rust/stage7.rs | 4 +- .../src/protocols/jolt/rust_target_plan.rs | 28 ++++---- crates/bolt/tests/verifier_cleanup.rs | 65 +++++++++++++++++++ crates/jolt-equivalence/src/plan_adapters.rs | 8 +-- crates/jolt-verifier/src/stages/stage2.rs | 6 +- crates/jolt-verifier/src/stages/stage3.rs | 4 +- crates/jolt-verifier/src/stages/stage4.rs | 16 ++--- crates/jolt-verifier/src/stages/stage5.rs | 16 ++--- crates/jolt-verifier/src/stages/stage6.rs | 19 +++--- crates/jolt-verifier/src/stages/stage7.rs | 4 +- 19 files changed, 233 insertions(+), 178 deletions(-) diff --git a/crates/bolt-verifier-runtime/src/lib.rs b/crates/bolt-verifier-runtime/src/lib.rs index 3675cbed02..ed1deef9bc 100644 --- a/crates/bolt-verifier-runtime/src/lib.rs +++ b/crates/bolt-verifier-runtime/src/lib.rs @@ -350,10 +350,7 @@ pub struct SumcheckInstanceResultPlan { pub enum SumcheckPointOrder { AsIs, Reverse, - Stage4RegistersReadWrite, - InstructionReadRaf, - BytecodeReadRaf, - Stage6Booleanity, + RelationLocal, } impl SumcheckPointOrder { @@ -361,10 +358,7 @@ impl SumcheckPointOrder { match self { Self::AsIs => "as_is", Self::Reverse => "reverse", - Self::Stage4RegistersReadWrite => "stage4_registers_rw", - Self::InstructionReadRaf => "instruction_read_raf", - Self::BytecodeReadRaf => "bytecode_read_raf", - Self::Stage6Booleanity => "stage6_booleanity", + Self::RelationLocal => "relation_local", } } } @@ -881,7 +875,6 @@ impl ValueStore { .evals .iter() .find(|value| value.name == eval.name) - .or_else(|| output.evals.get(eval.index)) .ok_or_else(|| missing_value(eval.symbol))? .value; self.insert_scalar(eval.symbol, value); @@ -2108,10 +2101,10 @@ mod tests { use super::{ evaluate_relation_output_for_instance, evaluate_scalar_expr, FieldExprKind, FieldExprPlan, Fr, NamedEvalFamilyPlan, RelationOutputPlan, RuntimePlanError, ScalarExprKind, - ScalarExprPlan, StageNamedEval, StructuredPolynomialKind, StructuredPolynomialPointLength, - StructuredPolynomialPointOrder, StructuredPolynomialPointSegment, - StructuredPolynomialPointTransform, SumcheckInstanceResultPlan, SumcheckPointOrder, - ValueStore, + ScalarExprPlan, StageNamedEval, StageSumcheckOutput, StructuredPolynomialKind, + StructuredPolynomialPointLength, StructuredPolynomialPointOrder, + StructuredPolynomialPointSegment, StructuredPolynomialPointTransform, SumcheckEvalPlan, + SumcheckInstanceResultPlan, SumcheckPointOrder, SumcheckProof, ValueStore, }; #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -2157,6 +2150,49 @@ mod tests { ); } + #[test] + fn value_store_requires_sumcheck_eval_names_to_match() { + let mut store = ValueStore::default(); + let instance_results: &[SumcheckInstanceResultPlan] = &[]; + let error = store + .observe_sumcheck_output( + instance_results, + &[SumcheckEvalPlan { + symbol: "planned.eval", + source: "driver", + name: "planned.eval.name", + index: 0, + oracle: "Oracle", + }], + &StageSumcheckOutput { + driver: "driver", + point: Vec::new(), + evals: vec![StageNamedEval { + name: "wrong.eval.name", + oracle: "Oracle", + value: Fr::from_u64(7), + }], + proof: SumcheckProof::default(), + }, + |_, point| Ok(point), + |input, expected, actual| RuntimePlanError::InvalidInputLength { + input, + expected, + actual, + }, + |symbol| RuntimePlanError::MissingValue { symbol }, + ) + .unwrap_err(); + + assert_eq!( + error, + RuntimePlanError::MissingValue { + symbol: "planned.eval" + } + ); + assert_eq!(store.try_scalar("planned.eval"), None); + } + #[test] fn value_store_evaluates_field_vector_exprs() { let mut store = ValueStore::default(); diff --git a/crates/bolt/GOAL.md b/crates/bolt/GOAL.md index 87dafebc01..f45bfb76c0 100644 --- a/crates/bolt/GOAL.md +++ b/crates/bolt/GOAL.md @@ -25,15 +25,15 @@ stage6 + stage7: ~13.2k LOC verifier.rs: 649 LOC ``` -Current locked cleanup baseline (post-S1 audit-tier split): +Current cleanup baseline (S2.75-S5 verifier-program cutover): ```text -generated jolt-verifier total: 7,905 LOC -generated verifier surface: 6,002 LOC -tier A (Bolt verifier runtime): 1,265 LOC stages/common.rs -tier B (Jolt verifier core): 638 LOC stages/jolt_relations.rs -stage6 + stage7: 1,660 LOC -verifier.rs: 428 LOC +generated jolt-verifier total: 6,752 LOC +generated verifier surface: 6,056 LOC +tier A (Bolt verifier runtime): 2,520 LOC crates/bolt-verifier-runtime/src/lib.rs +tier B (Jolt verifier core): 696 LOC stages/jolt_relations.rs +stage6 + stage7: 1,547 LOC +verifier.rs: 696 LOC ``` The shared runtime is now split along an explicit audit boundary. See @@ -85,10 +85,10 @@ growth is attributed to the right trust boundary. - **Tier A (Bolt verifier runtime):** generic, protocol-agnostic helpers (plan structs, `ValueStore`, sumcheck driver loop, opening-equality interpreter, transcript helpers). Lives in - `crates/jolt-verifier/src/stages/common.rs`, generated from - `crates/bolt/src/protocols/jolt/verifier_common.rs.template`. Tier A should - ratchet *down* over time as more helpers move into typed plan data driven - from MLIR. + `crates/bolt-verifier-runtime/src/lib.rs` as a standalone workspace crate. + Tier A should ratchet *down* over time as more helpers move into typed plan + data driven from MLIR. It must stay protocol-neutral; Jolt-specific math and + point normalization belong in Tier B or typed Jolt plan data. - **Tier B (audited Jolt verifier core):** hand-written Jolt-specific verifier math and relations (Stage 6/7 evaluators, `normalize_*_point`, @@ -183,7 +183,7 @@ generic artifact assembly no longer owns Jolt artifact APIs root bolt exports keep Jolt helpers under bolt::protocols::jolt generic compiler source is guarded against accidental Jolt protocol strings checked-in generated verifier is under the current LOC target -shared verifier plan/runtime scaffolding exists in stages/common.rs +shared verifier plan/runtime scaffolding lives in crates/bolt-verifier-runtime ``` The remaining work is no longer a stage bring-up task or a pure LOC cleanup. @@ -529,10 +529,11 @@ Readability and LOC gates (enforced by `crates/bolt/tests/verifier_cleanup.rs`): ```text total generated jolt-verifier LOC trends down -generated verifier surface (Tier C) <= 6.1k, target <= 6k, stretch <= 3k -tier A bolt verifier runtime <= 1.4k, ratcheting down +generated verifier surface (Tier C) <= 6.5k, target <= 6k, stretch <= 3k +generated Tier A surface in jolt-verifier stays at zero; standalone +bolt-verifier-runtime ratchets down separately tier B audited Jolt verifier core <= 700 (growth requires protocol-math review) -verifier.rs <= 500 LOC, stretch <= 350 +verifier.rs <= 850 LOC today, target <= 500 LOC, stretch <= 350 stage6 + stage7 generated LOC <= 3k-5k, stretch <= 2k-3k no duplicate stage-local generic plan structs no duplicate stage-local field-expression interpreter diff --git a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md index 5e1cfdafee..1b3e65f091 100644 --- a/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md +++ b/crates/bolt/VERIFIER_PROGRAM_REFACTOR_PLAN.md @@ -13,12 +13,12 @@ transcript events, sumcheck drivers, value-graph computations, opening batches, and PCS checks. S1 (the audit-tier split that landed in PR #1523) reframes the shared -verifier runtime as two explicitly-bounded tiers: +verifier runtime as explicitly-bounded tiers: ```text -Tier A (Bolt verifier runtime) stages/common.rs 1,265 LOC -Tier B (audited Jolt verifier core) stages/jolt_relations.rs 638 LOC -Tier C (generated stage data + verifier.rs) 6,430 LOC +Tier A (Bolt verifier runtime) bolt-verifier-runtime/src/lib.rs ~2.5k LOC +Tier B (audited Jolt verifier core) stages/jolt_relations.rs 696 LOC +Tier C (generated stage data + verifier.rs) ~6.1k LOC ``` The current stack has already moved beyond the original S1 framing: @@ -296,10 +296,10 @@ projected/operand polynomial evaluation. ### Concrete plumbing already done or retained 1. New crate `crates/bolt-verifier-runtime/` with `src/lib.rs` seeded from - today's `crates/bolt/src/protocols/jolt/verifier_common.rs.template`, but - reviewed as a public runtime API rather than copied verbatim. At minimum: - cross-crate paths, the error-conversion macro, and protocol-ID ownership - must be corrected during the move. + the old verifier-common template, but reviewed as a public runtime API + rather than copied verbatim. At minimum: cross-crate paths, the + error-conversion macro, and protocol-ID ownership must be corrected during + the move. 2. Workspace `Cargo.toml` registers the new crate. 3. `crates/bolt/src/protocols/jolt/artifacts.rs::verifier_runtime_modules` stops emitting the `common` module (the `ProtocolRuntimeModule` entry @@ -868,10 +868,10 @@ deleting more Tier B prefix code. ### Blockers and complications - **Proof format.** The proof's `evals` field is already - `Vec>` with explicit `name` strings (verified in - `verifier_common.rs.template:393-397`). S4 changes how the *verifier - consumes* named evals, not how they are serialized. No back-compat - break. *This was the biggest risk; it is not real.* + `Vec>` with explicit `name` strings in the extracted + `bolt-verifier-runtime` API. S4 changes how the *verifier consumes* named + evals, not how they are serialized. No back-compat break. *This was the + biggest risk; it is not real.* - **Prover/verifier symmetry.** The prover-side emitter must annotate the same eval block as a family. If this is a separate emitter, both must be updated together. diff --git a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs index b20f3a4896..a6a9af1c5e 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/plan_tokens.rs @@ -49,17 +49,6 @@ pub(super) fn role_claim_kind_expr( claim_kind_expr(stage_type_prefix, kind) } -pub(super) fn role_field_expr_kind_expr( - stage_type_prefix: &str, - role: &Role, - formula: &str, -) -> Result { - if role == &Role::Prover { - return Ok(format!("{formula:?}")); - } - field_expr_kind_expr(stage_type_prefix, formula) -} - pub(super) fn rust_str_slice_expr(values: &[String]) -> String { if values.is_empty() { return "&[]".to_owned(); @@ -559,13 +548,6 @@ fn relation_kind_expr(stage_type_prefix: &str, relation: &str) -> Result Result { - let variant = FieldExprKind::from_cpu_attr(formula) - .map_err(plan_error)? - .rust_variant_expr(); - Ok(format!("{stage_type_prefix}FieldExprKind::{variant}")) -} - fn sumcheck_point_order_expr(point_order: &str) -> Result { let variant = SumcheckPointOrder::from_cpu_attr(point_order) .map_err(plan_error)? diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs index 471c3783ee..25e4e0469d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage2.rs @@ -7,8 +7,7 @@ use melior::ir::{Attribute, OperationRef}; use crate::emit::rust::{push_format, EmitError, RustSourceFile}; use crate::ir::{string_attribute_value, symbol_attribute_value, BoltModule, Cpu, Role}; use crate::protocols::jolt::rust_target_plan::{ - structured_polynomial_scalar_formula, JoltVerifierRelationKind, RustTargetPlanError, - ScalarExprKind, + structured_polynomial_scalar_formula, JoltVerifierRelationKind, }; use crate::protocols::jolt::verifier_opening_rows; use crate::protocols::jolt::verifier_plan::{self, VerifierStagePlan}; @@ -1569,25 +1568,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); fn emit_field_expr_constants(&self) -> Result { if self.role == Role::Verifier { - let exprs = self - .field_exprs - .iter() - .map(|expr| { - Ok(format!( - " Stage2FieldExprPlan {{ symbol: {}, kind: {}, operands: {} }},", - rust_str(&expr.symbol), - super::plan_tokens::role_field_expr_kind_expr( - "Stage2", - &self.role, - &expr.formula - )?, - super::plan_tokens::rust_str_slice_expr(&expr.operands) - )) - }) - .collect::, EmitError>>()? - .join("\n"); - return Ok(format!( - "pub const STAGE2_FIELD_EXPRS: &[Stage2FieldExprPlan] = &[\n{exprs}\n];\n" + let plan = self.verifier_plan()?; + return Ok(verifier_plan::emit_field_expr_constants( + "Stage2", + "STAGE2", + &plan.field_exprs, )); } @@ -1634,23 +1619,11 @@ bolt_verifier_runtime::impl_runtime_plan_error_conversion!(VerifyStage2Error); } fn emit_scalar_expr_constants(&self) -> Result { - let exprs = self - .scalar_exprs - .iter() - .map(|expr| { - let kind = ScalarExprKind::from_cpu_attr(&expr.formula) - .map_err(rust_target_plan_error)? - .rust_variant_expr(); - Ok(format!( - " Stage2ScalarExprPlan {{ symbol: {}, kind: Stage2ScalarExprKind::{kind}, operands: {} }},", - rust_str(&expr.symbol), - super::plan_tokens::rust_str_slice_expr(&expr.operands) - )) - }) - .collect::, EmitError>>()? - .join("\n"); - Ok(format!( - "pub const STAGE2_SCALAR_EXPRS: &[Stage2ScalarExprPlan] = &[\n{exprs}\n];\n" + let plan = self.verifier_plan()?; + Ok(verifier_plan::emit_scalar_expr_constants( + "Stage2", + "STAGE2", + &plan.scalar_exprs, )) } @@ -2448,13 +2421,13 @@ impl Stage2ValueStore { program.evals, output, |instance, mut point| { - match instance.point_order { + match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - _ => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { return Err(VerifyStage2Error::InvalidProof { driver: output.driver, - reason: "unsupported point order", + reason: "unsupported relation-local point order", }); } } @@ -2768,10 +2741,6 @@ fn require_supported_symbol(kind: &str, actual: &str, expected: &str) -> Result< } } -fn rust_target_plan_error(error: RustTargetPlanError) -> EmitError { - EmitError::new(error.to_string()) -} - fn emit_str_array(name: &str, values: &[String]) -> String { if values.is_empty() { return format!("pub const {name}: &[&str] = &[];\n\n"); diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs index 5ce1a2b656..4f10f22bcd 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage3.rs @@ -1759,10 +1759,10 @@ fn observe_stage3_sumcheck_output( match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - _ => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { return Err(VerifyStage3Error::InvalidProof { driver: output.driver, - reason: "unsupported point order", + reason: "unsupported relation-local point order", }); } } diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs index 1dbf3de714..568a102803 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage4.rs @@ -2016,15 +2016,15 @@ fn observe_stage4_sumcheck_output( match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - bolt_verifier_runtime::SumcheckPointOrder::Stage4RegistersReadWrite => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { + if instance.relation != Stage4RelationKind::Stage4RegistersReadWrite { + return Err(VerifyStage4Error::InvalidProof { + driver: output.driver, + reason: "unsupported relation-local point order", + }); + } point = normalize_stage4_registers_rw_point(program, output.driver, &point)?; } - _ => { - return Err(VerifyStage4Error::InvalidProof { - driver: output.driver, - reason: "unsupported point order", - }); - } } Ok(point) }, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs index aca4bd9383..6abc0f321d 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage5.rs @@ -2127,15 +2127,15 @@ fn observe_stage5_sumcheck_output( match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - bolt_verifier_runtime::SumcheckPointOrder::InstructionReadRaf => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { + if instance.relation != Stage5RelationKind::Stage5InstructionReadRaf { + return Err(VerifyStage5Error::InvalidProof { + driver: output.driver, + reason: "unsupported relation-local point order", + }); + } point = normalize_instruction_read_raf_point(&point, "stage5.instruction_read_raf.point")?; } - _ => { - return Err(VerifyStage5Error::InvalidProof { - driver: output.driver, - reason: "unsupported point order", - }); - } } Ok(point) }, diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs index a2045fc14b..1b2d2b15eb 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage6.rs @@ -2252,13 +2252,14 @@ fn observe_stage6_sumcheck_output( match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - bolt_verifier_runtime::SumcheckPointOrder::BytecodeReadRaf => point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?, - bolt_verifier_runtime::SumcheckPointOrder::Stage6Booleanity => {} - _ => { - return Err(VerifyStage6Error::InvalidProof { - driver: output.driver, - reason: "unsupported point order", - }); + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { + if instance.relation != Stage6RelationKind::Stage6BytecodeReadRaf { + return Err(VerifyStage6Error::InvalidProof { + driver: output.driver, + reason: "unsupported relation-local point order", + }); + } + point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?; } } Ok(point) diff --git a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs index 6ab8c8d271..c362ff6ef8 100644 --- a/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs +++ b/crates/bolt/src/protocols/jolt/emit/rust/stage7.rs @@ -2242,10 +2242,10 @@ fn observe_stage7_sumcheck_output( match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - _ => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { return Err(VerifyStage7Error::InvalidProof { driver: output.driver, - reason: "unsupported point order", + reason: "unsupported relation-local point order", }); } } diff --git a/crates/bolt/src/protocols/jolt/rust_target_plan.rs b/crates/bolt/src/protocols/jolt/rust_target_plan.rs index b132a9cd09..ca434d8390 100644 --- a/crates/bolt/src/protocols/jolt/rust_target_plan.rs +++ b/crates/bolt/src/protocols/jolt/rust_target_plan.rs @@ -106,10 +106,7 @@ impl ClaimKind { pub(crate) enum SumcheckPointOrder { AsIs, Reverse, - Stage4RegistersReadWrite, - InstructionReadRaf, - BytecodeReadRaf, - Stage6Booleanity, + RelationLocal, } impl SumcheckPointOrder { @@ -117,10 +114,10 @@ impl SumcheckPointOrder { match value { "as_is" => Ok(Self::AsIs), "reverse" => Ok(Self::Reverse), - "stage4_registers_rw" => Ok(Self::Stage4RegistersReadWrite), - "instruction_read_raf" => Ok(Self::InstructionReadRaf), - "bytecode_read_raf" => Ok(Self::BytecodeReadRaf), - "stage6_booleanity" => Ok(Self::Stage6Booleanity), + "stage4_registers_rw" | "instruction_read_raf" | "bytecode_read_raf" => { + Ok(Self::RelationLocal) + } + "stage6_booleanity" => Ok(Self::AsIs), _ => Err(RustTargetPlanError::unsupported( "sumcheck point order", value, @@ -132,10 +129,7 @@ impl SumcheckPointOrder { match self { Self::AsIs => "AsIs", Self::Reverse => "Reverse", - Self::Stage4RegistersReadWrite => "Stage4RegistersReadWrite", - Self::InstructionReadRaf => "InstructionReadRaf", - Self::BytecodeReadRaf => "BytecodeReadRaf", - Self::Stage6Booleanity => "Stage6Booleanity", + Self::RelationLocal => "RelationLocal", } } } @@ -792,7 +786,7 @@ mod tests { ClaimKind, FieldExprKind, JoltVerifierRelationKind, OpeningEqualityMode, PcsProofMode, ProgramStepKind, ScalarExprKind, StructuredPolynomialKind, StructuredPolynomialPointLength, StructuredPolynomialPointOrder, StructuredPolynomialPointSegment, - StructuredPolynomialPointTransform, TranscriptSqueezeKind, + StructuredPolynomialPointTransform, SumcheckPointOrder, TranscriptSqueezeKind, }; #[test] @@ -821,6 +815,14 @@ mod tests { OpeningEqualityMode::from_cpu_attr("point_and_eval").ok(), Some(OpeningEqualityMode::PointAndEval) ); + assert_eq!( + SumcheckPointOrder::from_cpu_attr("instruction_read_raf").ok(), + Some(SumcheckPointOrder::RelationLocal) + ); + assert_eq!( + SumcheckPointOrder::from_cpu_attr("stage6_booleanity").ok(), + Some(SumcheckPointOrder::AsIs) + ); } #[test] diff --git a/crates/bolt/tests/verifier_cleanup.rs b/crates/bolt/tests/verifier_cleanup.rs index 42066bc0d0..f401f66b9e 100644 --- a/crates/bolt/tests/verifier_cleanup.rs +++ b/crates/bolt/tests/verifier_cleanup.rs @@ -504,6 +504,71 @@ fn verifier_runtime_has_no_indexed_eval_prefix_api() { } } +#[test] +fn verifier_runtime_has_no_name_then_position_eval_fallback() { + let runtime = workspace_root().join("crates/bolt-verifier-runtime/src/lib.rs"); + if !runtime.exists() { + return; + } + let source = std::fs::read_to_string(&runtime).expect("read verifier runtime source"); + for stale in [ + ".or_else(|| output.evals.get(eval.index))", + "output.evals.get(eval.index)", + ] { + assert!( + !source.contains(stale), + "bolt-verifier-runtime still accepts sumcheck evals by position fallback `{stale}`" + ); + } +} + +#[test] +fn verifier_runtime_has_no_jolt_specific_sumcheck_point_orders() { + let runtime = workspace_root().join("crates/bolt-verifier-runtime/src/lib.rs"); + if !runtime.exists() { + return; + } + let source = std::fs::read_to_string(&runtime).expect("read verifier runtime source"); + for stale in [ + "Stage4RegistersReadWrite", + "InstructionReadRaf", + "BytecodeReadRaf", + "Stage6Booleanity", + "stage4_registers_rw", + "instruction_read_raf", + "bytecode_read_raf", + "stage6_booleanity", + ] { + assert!( + !source.contains(stale), + "bolt-verifier-runtime still exposes Jolt-specific point order `{stale}`" + ); + } +} + +#[test] +fn verifier_goal_doc_tracks_extracted_runtime_boundary() { + let goal = workspace_root().join("crates/bolt/GOAL.md"); + if !goal.exists() { + return; + } + let source = std::fs::read_to_string(&goal).expect("read verifier goal doc"); + assert!( + source.contains("crates/bolt-verifier-runtime/src/lib.rs"), + "GOAL.md should name the extracted Bolt verifier runtime crate as Tier A" + ); + for stale in [ + "crates/jolt-verifier/src/stages/common.rs", + "crates/bolt/src/protocols/jolt/verifier_common.rs.template", + "shared verifier plan/runtime scaffolding exists in stages/common.rs", + ] { + assert!( + !source.contains(stale), + "GOAL.md still references deleted Tier A path `{stale}`" + ); + } +} + #[test] fn verifier_cpu_fixtures_are_kernel_free() { let fixtures = workspace_root().join("crates/bolt/tests/fixtures"); diff --git a/crates/jolt-equivalence/src/plan_adapters.rs b/crates/jolt-equivalence/src/plan_adapters.rs index f6cd0ab3ad..aa9501aa24 100644 --- a/crates/jolt-equivalence/src/plan_adapters.rs +++ b/crates/jolt-equivalence/src/plan_adapters.rs @@ -527,12 +527,10 @@ fn generated_sumcheck_point_order(value: &str) -> bolt_verifier_runtime::Sumchec match value { "as_is" => bolt_verifier_runtime::SumcheckPointOrder::AsIs, "reverse" => bolt_verifier_runtime::SumcheckPointOrder::Reverse, - "stage4_registers_rw" => { - bolt_verifier_runtime::SumcheckPointOrder::Stage4RegistersReadWrite + "stage4_registers_rw" | "instruction_read_raf" | "bytecode_read_raf" => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal } - "instruction_read_raf" => bolt_verifier_runtime::SumcheckPointOrder::InstructionReadRaf, - "bytecode_read_raf" => bolt_verifier_runtime::SumcheckPointOrder::BytecodeReadRaf, - "stage6_booleanity" => bolt_verifier_runtime::SumcheckPointOrder::Stage6Booleanity, + "stage6_booleanity" => bolt_verifier_runtime::SumcheckPointOrder::AsIs, value => panic!("unsupported generated sumcheck point order `{value}`"), } } diff --git a/crates/jolt-verifier/src/stages/stage2.rs b/crates/jolt-verifier/src/stages/stage2.rs index 935349014d..61880aa817 100644 --- a/crates/jolt-verifier/src/stages/stage2.rs +++ b/crates/jolt-verifier/src/stages/stage2.rs @@ -613,13 +613,13 @@ impl Stage2ValueStore { program.evals, output, |instance, mut point| { - match instance.point_order { + match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - _ => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { return Err(VerifyStage2Error::InvalidProof { driver: output.driver, - reason: "unsupported point order", + reason: "unsupported relation-local point order", }); } } diff --git a/crates/jolt-verifier/src/stages/stage3.rs b/crates/jolt-verifier/src/stages/stage3.rs index 0d894e9eb6..cda25b6582 100644 --- a/crates/jolt-verifier/src/stages/stage3.rs +++ b/crates/jolt-verifier/src/stages/stage3.rs @@ -425,10 +425,10 @@ fn observe_stage3_sumcheck_output( match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - _ => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { return Err(VerifyStage3Error::InvalidProof { driver: output.driver, - reason: "unsupported point order", + reason: "unsupported relation-local point order", }); } } diff --git a/crates/jolt-verifier/src/stages/stage4.rs b/crates/jolt-verifier/src/stages/stage4.rs index 9bfcbbaf82..659b814916 100644 --- a/crates/jolt-verifier/src/stages/stage4.rs +++ b/crates/jolt-verifier/src/stages/stage4.rs @@ -134,7 +134,7 @@ pub const STAGE4_SUMCHECK_DRIVERS: &[Stage4SumcheckDriverPlan] = &[ Stage4SumcheckDriverPlan { symbol: "stage4.sumcheck", stage: "stage4", proof_slot: "stage4.sumcheck", kernel: None, relation: Some(Stage4RelationKind::Stage4Batched), batch: "stage4.batch", policy: "jolt_core_stage4_aligned", round_schedule: STAGE4_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 23, degree: 3 }, ]; pub const STAGE4_SUMCHECK_INSTANCE_RESULTS: &[Stage4SumcheckInstanceResultPlan] = &[ - Stage4SumcheckInstanceResultPlan { symbol: "stage4.registers_read_write.instance", source: "stage4.sumcheck", claim: "stage4.registers_read_write.input", relation: Stage4RelationKind::Stage4RegistersReadWrite, index: 0, point_arity: 23, num_rounds: 23, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::Stage4RegistersReadWrite, degree: 3 }, + Stage4SumcheckInstanceResultPlan { symbol: "stage4.registers_read_write.instance", source: "stage4.sumcheck", claim: "stage4.registers_read_write.input", relation: Stage4RelationKind::Stage4RegistersReadWrite, index: 0, point_arity: 23, num_rounds: 23, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::RelationLocal, degree: 3 }, Stage4SumcheckInstanceResultPlan { symbol: "stage4.ram_val_check.instance", source: "stage4.sumcheck", claim: "stage4.ram_val_check.input", relation: Stage4RelationKind::Stage4RamValCheck, index: 1, point_arity: 16, num_rounds: 16, round_offset: 7, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, ]; @@ -404,15 +404,15 @@ fn observe_stage4_sumcheck_output( match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - bolt_verifier_runtime::SumcheckPointOrder::Stage4RegistersReadWrite => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { + if instance.relation != Stage4RelationKind::Stage4RegistersReadWrite { + return Err(VerifyStage4Error::InvalidProof { + driver: output.driver, + reason: "unsupported relation-local point order", + }); + } point = normalize_stage4_registers_rw_point(program, output.driver, &point)?; } - _ => { - return Err(VerifyStage4Error::InvalidProof { - driver: output.driver, - reason: "unsupported point order", - }); - } } Ok(point) }, diff --git a/crates/jolt-verifier/src/stages/stage5.rs b/crates/jolt-verifier/src/stages/stage5.rs index 0cf263f4f2..6d31cb01da 100644 --- a/crates/jolt-verifier/src/stages/stage5.rs +++ b/crates/jolt-verifier/src/stages/stage5.rs @@ -201,7 +201,7 @@ pub const STAGE5_SUMCHECK_DRIVERS: &[Stage5SumcheckDriverPlan] = &[ Stage5SumcheckDriverPlan { symbol: "stage5.sumcheck", stage: "stage5", proof_slot: "stage5.sumcheck", kernel: None, relation: Some(Stage5RelationKind::Stage5Batched), batch: "stage5.batch", policy: "jolt_core_stage5_aligned", round_schedule: STAGE5_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 144, degree: 10 }, ]; pub const STAGE5_SUMCHECK_INSTANCE_RESULTS: &[Stage5SumcheckInstanceResultPlan] = &[ - Stage5SumcheckInstanceResultPlan { symbol: "stage5.instruction_read_raf.instance", source: "stage5.sumcheck", claim: "stage5.instruction_read_raf.input", relation: Stage5RelationKind::Stage5InstructionReadRaf, index: 0, point_arity: 144, num_rounds: 144, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::InstructionReadRaf, degree: 10 }, + Stage5SumcheckInstanceResultPlan { symbol: "stage5.instruction_read_raf.instance", source: "stage5.sumcheck", claim: "stage5.instruction_read_raf.input", relation: Stage5RelationKind::Stage5InstructionReadRaf, index: 0, point_arity: 144, num_rounds: 144, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::RelationLocal, degree: 10 }, Stage5SumcheckInstanceResultPlan { symbol: "stage5.ram_ra_claim_reduction.instance", source: "stage5.sumcheck", claim: "stage5.ram_ra_claim_reduction.input", relation: Stage5RelationKind::Stage5RamRaClaimReduction, index: 1, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 2 }, Stage5SumcheckInstanceResultPlan { symbol: "stage5.registers_val_evaluation.instance", source: "stage5.sumcheck", claim: "stage5.registers_val_evaluation.input", relation: Stage5RelationKind::Stage5RegistersValEvaluation, index: 2, point_arity: 16, num_rounds: 16, round_offset: 128, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, ]; @@ -655,15 +655,15 @@ fn observe_stage5_sumcheck_output( match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - bolt_verifier_runtime::SumcheckPointOrder::InstructionReadRaf => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { + if instance.relation != Stage5RelationKind::Stage5InstructionReadRaf { + return Err(VerifyStage5Error::InvalidProof { + driver: output.driver, + reason: "unsupported relation-local point order", + }); + } point = normalize_instruction_read_raf_point(&point, "stage5.instruction_read_raf.point")?; } - _ => { - return Err(VerifyStage5Error::InvalidProof { - driver: output.driver, - reason: "unsupported point order", - }); - } } Ok(point) }, diff --git a/crates/jolt-verifier/src/stages/stage6.rs b/crates/jolt-verifier/src/stages/stage6.rs index 374252f352..564f4f2c95 100644 --- a/crates/jolt-verifier/src/stages/stage6.rs +++ b/crates/jolt-verifier/src/stages/stage6.rs @@ -367,8 +367,8 @@ pub const STAGE6_SUMCHECK_DRIVERS: &[Stage6SumcheckDriverPlan] = &[ Stage6SumcheckDriverPlan { symbol: "stage6.sumcheck", stage: "stage6", proof_slot: "stage6.sumcheck", kernel: None, relation: Some(Stage6RelationKind::Stage6Batched), batch: "stage6.batch", policy: "jolt_core_stage6_aligned", round_schedule: STAGE6_SUMCHECK_DRIVER_0_ROUND_SCHEDULE, claim_label: "sumcheck_claim", round_label: "sumcheck_poly", num_rounds: 26, degree: 5 }, ]; pub const STAGE6_SUMCHECK_INSTANCE_RESULTS: &[Stage6SumcheckInstanceResultPlan] = &[ - Stage6SumcheckInstanceResultPlan { symbol: "stage6.bytecode_read_raf.instance", source: "stage6.sumcheck", claim: "stage6.bytecode_read_raf.input", relation: Stage6RelationKind::Stage6BytecodeReadRaf, index: 0, point_arity: 26, num_rounds: 26, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::BytecodeReadRaf, degree: 4 }, - Stage6SumcheckInstanceResultPlan { symbol: "stage6.booleanity.instance", source: "stage6.sumcheck", claim: "stage6.booleanity.input", relation: Stage6RelationKind::Stage6Booleanity, index: 1, point_arity: 20, num_rounds: 20, round_offset: 6, point_order: bolt_verifier_runtime::SumcheckPointOrder::Stage6Booleanity, degree: 3 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.bytecode_read_raf.instance", source: "stage6.sumcheck", claim: "stage6.bytecode_read_raf.input", relation: Stage6RelationKind::Stage6BytecodeReadRaf, index: 0, point_arity: 26, num_rounds: 26, round_offset: 0, point_order: bolt_verifier_runtime::SumcheckPointOrder::RelationLocal, degree: 4 }, + Stage6SumcheckInstanceResultPlan { symbol: "stage6.booleanity.instance", source: "stage6.sumcheck", claim: "stage6.booleanity.input", relation: Stage6RelationKind::Stage6Booleanity, index: 1, point_arity: 20, num_rounds: 20, round_offset: 6, point_order: bolt_verifier_runtime::SumcheckPointOrder::AsIs, degree: 3 }, Stage6SumcheckInstanceResultPlan { symbol: "stage6.hamming_booleanity.instance", source: "stage6.sumcheck", claim: "stage6.hamming_booleanity.input", relation: Stage6RelationKind::Stage6HammingBooleanity, index: 2, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 3 }, Stage6SumcheckInstanceResultPlan { symbol: "stage6.ram_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.ram_ra_virtual.input", relation: Stage6RelationKind::Stage6RamRaVirtual, index: 3, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 5 }, Stage6SumcheckInstanceResultPlan { symbol: "stage6.instruction_ra_virtual.instance", source: "stage6.sumcheck", claim: "stage6.instruction_ra_virtual.input", relation: Stage6RelationKind::Stage6InstructionRaVirtual, index: 4, point_arity: 16, num_rounds: 16, round_offset: 10, point_order: bolt_verifier_runtime::SumcheckPointOrder::Reverse, degree: 5 }, @@ -925,13 +925,14 @@ fn observe_stage6_sumcheck_output( match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - bolt_verifier_runtime::SumcheckPointOrder::BytecodeReadRaf => point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?, - bolt_verifier_runtime::SumcheckPointOrder::Stage6Booleanity => {} - _ => { - return Err(VerifyStage6Error::InvalidProof { - driver: output.driver, - reason: "unsupported point order", - }); + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { + if instance.relation != Stage6RelationKind::Stage6BytecodeReadRaf { + return Err(VerifyStage6Error::InvalidProof { + driver: output.driver, + reason: "unsupported relation-local point order", + }); + } + point = normalize_bytecode_read_raf_point(&point, stage6_trace_rounds(program)?, "stage6.bytecode_read_raf.point")?; } } Ok(point) diff --git a/crates/jolt-verifier/src/stages/stage7.rs b/crates/jolt-verifier/src/stages/stage7.rs index d12feb9bb5..c22bec670c 100644 --- a/crates/jolt-verifier/src/stages/stage7.rs +++ b/crates/jolt-verifier/src/stages/stage7.rs @@ -508,10 +508,10 @@ fn observe_stage7_sumcheck_output( match instance.point_order { bolt_verifier_runtime::SumcheckPointOrder::AsIs => {} bolt_verifier_runtime::SumcheckPointOrder::Reverse => point.reverse(), - _ => { + bolt_verifier_runtime::SumcheckPointOrder::RelationLocal => { return Err(VerifyStage7Error::InvalidProof { driver: output.driver, - reason: "unsupported point order", + reason: "unsupported relation-local point order", }); } }